Progressive Self-Healing Neural Networks: An Integrated Framework for Resilient Continual Learning in Non-Stationary Environments

1. Introduction

Modern machine learning systems are increasingly deployed in settings where data and task distributions are non-stationary. Robotics, healthcare monitoring, autonomous decision-making, and edge computing all require models that adapt to new conditions without losing prior knowledge. This exposes the well-known problem of catastrophic forgetting [3], where gradient descent on new tasks overwrites representations critical for earlier ones.

A parallel, and until recently, largely separate challenge concerns parameter corruption: the degradation of stored weights due to hardware faults, adversarial perturbation, storage errors, or concept drift. Unlike forgetting, corruption can occur instantaneously and without new learning, rendering task-specific modules entirely non-functional while leaving others intact. Despite its practical importance in long-running production systems, parameter corruption in continual learners has received little systematic attention.

Existing continual learning methods [1] address forgetting through regularisation [3], replay [7,12], or architectural expansion [13]. Self-healing and fault-tolerant systems [8] address degradation but assume a single static model. The gap is clear: no existing framework simultaneously supports sequential knowledge accumulation and autonomous recovery from corruption.

This paper proposes Progressive Self-Healing Neural Networks (PSHNN), which closes this gap. PSHNN combines a column-structured progressive architecture with an autonomic controller that monitors, detects, and repairs column-level corruption. Our principal contributions are:

• A continual learning architecture combining progressive task columns with an autonomous self-healing controller, formally treating healing and forgetting prevention as complementary rather than orthogonal requirements.
• A dual-signal monitoring loop based on accuracy-drop detection and Population Stability Index (PSI) drift, with formal trigger conditions and a locality guarantee ensuring that healing one column cannot degrade others.
• Comprehensive empirical evaluation on Split-MNIST, Split-CIFAR-10, and Split-CIFAR-100 demonstrating full post-corruption recovery and near-zero forgetting.
• An identification and analysis of a positive transfer effect during healing, in which replay-driven encoder updates improve accuracy on unaffected prior tasks as a by-product of recovery.

2. Related Work

2.1. Continual Learning

Continual learning addresses sequential knowledge acquisition without forgetting [11]. Regularisation methods such as Elastic Weight Consolidation [3] and Synaptic Intelligence [16] add penalties to prevent changes to weights important for past tasks. Replay methods [7,12] maintain exemplar buffers that are interleaved with new-task training. Architectural methods allocate new model capacity per task: PackNet [9] uses weight pruning and masking; DEN [15] selectively expands the network. PSHNN belongs to the architectural family but augments it with a healing loop.

2.2. Progressive Neural Networks

Progressive Neural Networks (PNN) [13] instantiate a new column per task and freeze earlier columns, using lateral connections to enable forward knowledge transfer without backward interference. This structure provides a strong guarantee against forgetting but grows linearly in task count and provides no mechanism for recovering from column-level corruption. PSHNN retains the column structure and lateral connections while adding the repair capability that PNNs lack.

2.3. Self-Healing and Fault Tolerance

Self-healing systems detect and recover from model degradation [2,8]. Hardware-oriented work addresses stuck-at faults in neuromorphic devices [14]; adversarial robustness work addresses inference-time weight perturbation. To our knowledge, no prior work addresses autonomous detection and recovery from persistent parameter corruption within a multi-task continual learner. PSHNN fills this niche.

2.4. Research Gap

The key gap is the absence of a unified framework supporting both sequential knowledge accumulation and autonomous repair. PSHNN bridges this gap by treating the two requirements as complementary architectural primitives.

3. Problem Formulation

Let the model observe a task sequence $\mathcal{D}=\{D_1,D_2,\dots ,D_T\}$, where $D_t={\left\{({\mathbf{x}}_i,y_i)\right\}}_{i=1}^{N_t}$ comprises labelled samples from a task-specific distribution $P_t(\mathbf{x},y)$. The model must:

• Achieve high accuracy on the current task.
• Retain accuracy on all prior tasks (no forgetting).
• Recover full accuracy after structural parameter corruption.

Definition 1 (Catastrophic Forgetting).

For a model trained sequentially on $D_1,\dots ,D_T$, catastrophic forgetting occurs when $\mathcal{A}(D_t;{\theta }_T)\ll \mathcal{A}(D_t;{\theta }_t)$ for some $t<T$, where $\mathcal{A}$ denotes accuracy and ${\theta }_{\tau }$ the parameters after training task τ.

Definition 2 (Average Forgetting).

$$\mathcal{F}={\displaystyle \frac{1}{T-1}}{\displaystyle \sum _{t=1}^{T-1}}max\left(0,\mathcal{A}(D_t;{\theta }_t)-\mathcal{A}(D_t;{\theta }_T)\right).$$

(1)

The total training objective is:

$${\mathcal{L}}_{\mathrm{total}}={\mathcal{L}}_{\mathrm{task}}+\lambda {\mathcal{L}}_{\mathrm{replay}}+\mu {\mathcal{L}}_{\mathrm{distill}},$$

(2)

where ${\mathcal{L}}_{\mathrm{task}}$ is the current task cross-entropy, ${\mathcal{L}}_{\mathrm{replay}}$ preserves prior knowledge via stored exemplars, and ${\mathcal{L}}_{\mathrm{distill}}$ stabilises repaired representations through knowledge distillation during healing.

4. Proposed Framework

4.1. Shared Encoder

Input $\mathbf{x}\in {\mathbb{R}}^d$ is first mapped to a shared latent representation:

$$\mathbf{z}=f_{\theta }\left(\mathbf{x}\right),f_{\theta }:{\mathbb{R}}^d\to {\mathbb{R}}^k.$$

(3)

The shared encoder captures cross-task reusable structure and reduces dimensionality before task-specific processing. As shown in Section 7, updates to $f_{\theta }$ during healing provide a secondary positive transfer benefit.

4.2. Progressive Columns with Lateral Transfer

For task t, PSHNN instantiates a dedicated column ${\mathcal{C}}_t$. Each column is a two-layer MLP with lateral connections from all prior columns. For layer ℓ in column k:

$${\mathbf{h}}_{\ell }^{\left(k\right)}=\sigma \left(W_{\ell }^{\left(k\right)}{\mathbf{h}}_{\ell -1}^{\left(k\right)}+\sum _{j<k}{U}_{\ell }^{(k:j)}{\mathbf{h}}_{\ell -1}^{\left(j\right)}\right),$$

(4)

where $W_{\ell }^{\left(k\right)}$ are column-specific weights, $U_{\ell }^{(k:j)}$ are lateral transfer weights from column j to column k at layer ℓ, and $\sigma$ is ReLU. All columns $j<k$ are frozen after their task completes.

Proposition 1 (Interference-Free Prior Tasks).

Because all parameters of columns $j<k$ are frozen during task k training, ${\nabla }_{{\theta }_j}{\mathcal{L}}_{\mathrm{task}}^{\left(k\right)}=\mathbf{0}$ for all $j<k$. Prior task representations are immune to direct interference.

The full sequential training procedure, including column allocation, replay buffer population, and baseline registration, is formalised as Algorithm 1 in Section 5.

4.3. Task-Specific Heads

Each task has a dedicated classifier:

$${\widehat{y}}_t=\mathrm{softmax}\left({\mathrm{Head}}_t\left({\mathbf{h}}_2^{\left(t\right)}\right)\right),$$

(5)

where ${\mathbf{h}}_2^{\left(t\right)}$ is the final column output. Task heads are frozen jointly with their column after training completes.

4.4. Episodic Memory Bank

A per-task replay buffer ${\mathcal{R}}_t$ stores up to M representative exemplars drawn uniformly from the training stream of $D_t$. The buffer is populated at training time, frozen thereafter, and used exclusively during the healing phase.

4.5. Autonomic Healing Controller

The healing controller monitors per-task validation accuracy and column activation statistics. Two complementary trigger conditions are evaluated at fixed monitoring intervals.

Accuracy-Drop Trigger.

$${\mathcal{A}}_{\mathrm{base}}^{\left(t\right)}-{\mathcal{A}}_{\mathrm{current}}^{\left(t\right)}>{\delta }_{\mathrm{acc}}=0.10.$$

(6)

Distributional Drift Trigger (PSI).

Let p and q be the baseline and recent activation distributions discretised into B bins. The Population Stability Index is:

$$\mathrm{PSI}(p\parallel q)={\displaystyle \sum _{b=1}^B}(p_b-q_b)ln{\displaystyle \frac{p_b}{q_b}}.$$

(7)

Healing is triggered when $\mathrm{PSI}>{\delta }_{\mathrm{PSI}}=0.25$, the standard threshold for significant distributional shift [10].

Healing Protocol.

When either trigger fires for task t, a five-step localise–reinitialise– replay–retrain–re-register procedure is executed; the complete formalisation is given as Algorithm 2 in Section 5.

The locality property follows directly: because only ${\mathcal{C}}_t$ is reinitialised and trained, and all other columns are frozen, healing cannot degrade any task $t^{\prime }\ne t$ through direct gradient flow.

4.6. Computational Complexity

For T tasks with $P_e$ encoder, $P_c$ per-column, and $P_h$ per-head parameters:

$$P_{\mathrm{total}}=P_e+T(P_c+P_h).$$

(8)

Parameter count grows linearly in T. Healing cost is proportional to $|{\mathcal{R}}_t|$ and $E_{\mathrm{heal}}$, independent of the total task count. Monitoring overhead is a constant-cost validation probe per task per interval.

Figure 1. PSHNN architecture (two-task illustration). The shared encoder $f_{\theta }$ produces $\mathbf{z}$ for all columns. Column A (purple) is frozen after Task A; Column B (blue) receives lateral transfer weights $U_{\ell }^{\left(10\right)}$ from Column A (Equation (4)). The healing controller (coral) monitors Column B via accuracy-drop (Equation (6)) and PSI (Equation (7)) triggers, executing the five-step healing protocol on detection. Replay memory (amber) stores exemplars per task and supplies ${\mathcal{L}}_{\mathrm{replay}}$ to the training objective.

Figure 1. PSHNN architecture (two-task illustration). The shared encoder $f_{\theta }$ produces $\mathbf{z}$ for all columns. Column A (purple) is frozen after Task A; Column B (blue) receives lateral transfer weights $U_{\ell }^{\left(10\right)}$ from Column A (Equation (4)). The healing controller (coral) monitors Column B via accuracy-drop (Equation (6)) and PSI (Equation (7)) triggers, executing the five-step healing protocol on detection. Replay memory (amber) stores exemplars per task and supplies ${\mathcal{L}}_{\mathrm{replay}}$ to the training objective.

5. Algorithms

This section formalises the two procedures underlying PSHNN: sequential progressive training (Algorithm 1) and the autonomic healing protocol (Algorithm 2) introduced in Section 4.

Algorithm 1 governs how the network grows over time. For each incoming task, a fresh column and classification head are instantiated while every previously trained column and head is frozen, which guarantees interference-free retention of earlier knowledge (Proposition 1). Once training on a task completes, a fixed-size subset of its data is retained in the replay buffer ${\mathcal{R}}_t$ and the task’s baseline accuracy ${\mathcal{A}}_{\mathrm{base}}^{\left(t\right)}$ is recorded; this baseline is what the healing controller later compares against to decide whether repair is required.

Algorithm 2 governs recovery. At each monitoring interval, every task column is probed against its own accuracy-drop and PSI drift triggers (Equations (6), (7)); whichever column exceeds either threshold is localised, reinitialised, and retrained exclusively from its own replay buffer, after which its baseline accuracy is re-registered so that future healing decisions are made relative to the restored state rather than the original one. Because retraining touches only the corrupted column’s parameters, the two algorithms compose without any additional synchronisation logic: training extends the network outward one column at a time, while healing repairs inward without ever crossing column boundaries. This separation of concerns is what allows the locality guarantee of Proposition 1 to carry over directly from the training phase to the healing phase.

Algorithm 1 PSHNN Sequential Progressive Training

Require:  Task stream $\{D_1,\dots ,D_T\}$; shared encoder $f_{\theta }$; epochs per task $E_{\mathrm{train}}$; replay buffer size M Ensure:  Trained encoder $f_{\theta }$, columns $\left\{{\mathcal{C}}_t\right\}$, heads $\left\{{\mathrm{Head}}_t\right\}$, replay buffers $\left\{{\mathcal{R}}_t\right\}$  1: for $t=1$ to T do  2:     Instantiate column ${\mathcal{C}}_t$ and head ${\mathrm{Head}}_t$  3:     Freeze $\{{\mathcal{C}}_j,{\mathrm{Head}}_j:j<t\}$  4:     for $e=1$ to $E_{\mathrm{train}}$ do  5:         for each mini-batch $(\mathbf{x},y)\sim D_t$ do  6:            $\mathbf{z}\leftarrow f_{\theta }\left(\mathbf{x}\right)$▹ Equation (3)  7:            ${\mathbf{h}}_{\ell }^{\left(t\right)}\leftarrow$ forward pass with lateral connections ▹ Equation (4)  8:            $\widehat{y}\leftarrow \mathrm{softmax}\left({\mathrm{Head}}_t\left({\mathbf{h}}_2^{\left(t\right)}\right)\right)$  9:            Compute ${\mathcal{L}}_{\mathrm{total}}$▹ Equation (2) 10:            Update $\theta$, $W_{\ell }^{\left(t\right)}$ via backpropagation 11:         end for 12:     end for 13:     Populate ${\mathcal{R}}_t$ with M exemplars sampled uniformly from $D_t$ 14:     Freeze ${\mathcal{C}}_t$, ${\mathrm{Head}}_t$ 15:     Record baseline accuracy ${\mathcal{A}}_{\mathrm{base}}^{\left(t\right)}$ 16: end for

Algorithm 2: Autonomic Healing Protocol

Require:  Trigger thresholds ${\delta }_{\mathrm{acc}}$, ${\delta }_{\mathrm{PSI}}$; monitoring interval; healing epochs $E_{\mathrm{heal}}$ Ensure:  Repaired column ${\mathcal{C}}_t$ with restored accuracy  1: for each monitoring interval do  2:     for each task $t=1$ to T do  3:         Compute ${\mathcal{A}}_{\mathrm{current}}^{\left(t\right)}$ and $\mathrm{PSI}(p_{\mathrm{base}}\parallel p_{\mathrm{recent}})$  4:         if ${\mathcal{A}}_{\mathrm{base}}^{\left(t\right)}-{\mathcal{A}}_{\mathrm{current}}^{\left(t\right)}>{\delta }_{\mathrm{acc}}$ or $\mathrm{PSI}>{\delta }_{\mathrm{PSI}}$ then ▹ Eqs. (6), (7)  5:            Localise: identify ${\mathcal{C}}_t$ as affected; all other columns remain frozen  6:            Reinitialise: reset $W_{\ell }^{\left(t\right)}$ using the original initialisation scheme  7:            Replay: load exemplars from ${\mathcal{R}}_t$ (optionally ${\mathcal{R}}_{t^{\prime }}$, $t^{\prime }<t$)  8:            Retrain: optimise ${\mathcal{C}}_t$ for $E_{\mathrm{heal}}$ epochs using ${\mathcal{L}}_{\mathrm{total}}$ ▹ Equation (2)  9:            Re-register: update ${\mathcal{A}}_{\mathrm{base}}^{\left(t\right)}$ 10:         end if 11:     end for 12: end for

6. Experimental Setup

6.1. Benchmarks

Split-MNIST. MNIST [5] is split into $T=2$ tasks of 5 classes each (digits 0–4 and 5–9). Widely used for its interpretability in continual learning research [1].

Split-CIFAR-10. CIFAR-10 [4] is split into $T=5$ tasks of 2 classes each, using random crop and horizontal flip augmentation.

Split-CIFAR-100. CIFAR-100 [4] is split into $T=20$ tasks of 5 classes each, the standard configuration for high-difficulty continual learning evaluation [1].

6.2. Architecture

Split-MNIST. Encoder: $784\to 128$ (FC + ReLU). Columns: two FC layers of width 128. Heads: FC to 5 classes.

Split-CIFAR-10/100. Encoder: $3072\to 512\to 256$ (FC + BN + ReLU + Dropout 0.3). Columns: two FC layers, width 256, with BatchNorm. Heads: FC to 2 or 5 classes.

6.3. Hyperparameters

Table 1. Hyperparameter settings across all benchmarks.

Hyperparameter	MNIST	CIFAR-10/100
Hidden size	128	256
Encoder depth	1 layer	2 layers
Optimiser	Adam	Adam
Learning rate	${10}^{-3}$	${10}^{-3}$
LR schedule	—	Cosine annealing
Batch size	128	128
Weight decay	—	${10}^{-4}$
Dropout	—	0.3
Epochs per task	5	15/20
Healing epochs	2	10
Replay buffer size	500	500
Acc. trigger ${\delta }_{\mathrm{acc}}$	0.10	0.10
PSI trigger ${\delta }_{\mathrm{PSI}}$	0.25	0.25

Table 1. Hyperparameter settings across all benchmarks.

Hyperparameter	MNIST	CIFAR-10/100
Hidden size	128	256
Encoder depth	1 layer	2 layers
Optimiser	Adam	Adam
Learning rate	${10}^{-3}$	${10}^{-3}$
LR schedule	—	Cosine annealing
Batch size	128	128
Weight decay	—	${10}^{-4}$
Dropout	—	0.3
Epochs per task	5	15/20
Healing epochs	2	10
Replay buffer size	500	500
Acc. trigger ${\delta }_{\mathrm{acc}}$	0.10	0.10
PSI trigger ${\delta }_{\mathrm{PSI}}$	0.25	0.25

6.4. Corruption Protocol

To evaluate resilience, the final task column (Task B for MNIST, Task 4 for CIFAR-10, Task 19 for CIFAR-100) is corrupted after training by overwriting all parameters with values drawn from $\mathcal{U}(-1,1)$—the worst-case corruption scenario. The healing controller then triggers and executes the repair protocol autonomously.

6.5. Evaluation Metrics

• Task accuracy ${\mathcal{A}}^{\left(t\right)}$: held-out test accuracy.
• Forgetting $\mathcal{F}$ (Equation (1)).
• Recovery gain: ${\mathcal{A}}_{\mathrm{heal}}^{\left(t\right)}-{\mathcal{A}}_{\mathrm{corrupt}}^{\left(t\right)}$ for the corrupted task.
• Transfer effect: change in prior-task accuracy after healing.

7. Results

7.1. Baseline Comparison

Table 2 compares PSHNN against four ablations and common baselines on Split-MNIST. Full PSHNN achieves the highest Task A retention and complete Task B recovery, which no other variant provides.

7.2. Split-MNIST

Table 3 reports per-stage accuracy. The controller correctly identifies Task B as the degraded column (accuracy drop $=0.774$) and classifies Task A as healthy. Task B recovers from 0.2076 to 0.9805, a recovery gain of +0.773. Task A forgetting is 0.018, substantially below the sequential fine-tuning baseline.

7.3. Split-CIFAR-10

Table 4 reports per-task accuracy across all five tasks. Task 4 collapses to 0.5000 (binary-classification chance) after corruption, confirming complete column failure. Healing restores accuracy to 0.8740, exceeding the pre-corruption baseline of 0.8670 (recovery gain $+0.374$).

Positive transfer during healing.

All four unaffected tasks improve after healing of Task 4. The mean accuracy across Tasks 0–3 increases from 0.7066 to 0.7490 ($\Delta =+0.042$). Overall mean accuracy rises from 0.7387 to 0.7740. This improvement arises because replay samples from all tasks update the shared encoder, improving its universal feature representations globally.

7.4. Split-CIFAR-100

Table 5 provides the complete 20-task breakdown. This is the most demanding evaluation, featuring 20 sequential five-way classification tasks.

Task 19 collapses from 0.7300 to 0.2000 after corruption—below the random five-class baseline of 0.200—confirming total column failure. The healing protocol restores accuracy to 0.7360, exceeding the pre-corruption value by $+0.006$.

Positive transfer at scale.

All 19 unaffected tasks meet or exceed their post-training accuracy after healing. Mean accuracy across Tasks 0–18 increases from 0.4934 to 0.5680 ($\Delta =+0.073$), the largest positive transfer effect observed across our benchmarks. The overall mean rises from 0.5072 to 0.5799.

Strongest per-task improvements.

Task 4 exhibits the largest individual gain ($+0.326$: from 0.310 to 0.636), followed by Task 9 ($+0.082$), Task 12 ($+0.066$), and Task 18 ($+0.068$). Tasks with smaller post-training baselines tend to show larger healing-induced gains, consistent with the hypothesis that encoder refinement during replay primarily benefits tasks whose original training coincided with a less mature shared representation.

7.5. Ablation Study

Table 6 isolates the contribution of each PSHNN component on Split-MNIST. The healing module is the critical component for post- corruption recovery; replay is critical for preventing forgetting during healing; lateral connections improve transfer and retention.

7.6. Cross-Benchmark Summary

Table 7 consolidates recovery gain, forgetting, and final mean accuracy across all three benchmarks.

Figure 2. Per-task accuracy on Split-CIFAR-10 across three pipeline stages. Task 4 collapses to chance level (0.50) after corruption and recovers beyond the original baseline after healing. Tasks 0–3 all improve, demonstrating positive transfer from replay-driven encoder updates.

Figure 2. Per-task accuracy on Split-CIFAR-10 across three pipeline stages. Task 4 collapses to chance level (0.50) after corruption and recovers beyond the original baseline after healing. Tasks 0–3 all improve, demonstrating positive transfer from replay-driven encoder updates.

Figure 3. Per-task accuracy on Split-CIFAR-100 before and after healing. Task 19 (corrupted to 0.200) is fully restored. Every other task improves after healing, evidencing positive transfer from replay-driven encoder updates across all 20 tasks.

Figure 3. Per-task accuracy on Split-CIFAR-100 before and after healing. Task 19 (corrupted to 0.200) is fully restored. Every other task improves after healing, evidencing positive transfer from replay-driven encoder updates across all 20 tasks.

8. Discussion

8.1. Healing Without Forgetting

The locality guarantee of Proposition 1 ensures that healing one column cannot degrade another through direct gradient flow. Empirically, 58 of 59 task-by-task comparisons across three benchmarks show zero forgetting after healing. The single exception is Split-MNIST Task A ($-0.018$), attributable to mild encoder drift—an expected cost of the shared encoder design and substantially lower than the $-0.476$ degradation observed under sequential fine-tuning.

8.2. Positive Transfer During Healing

The positive transfer effect—improvement in unaffected tasks as a by-product of healing—was not anticipated by the framework design and is the most significant empirical finding of this paper.

During healing of the corrupted column, the shared encoder $f_{\theta }$ is updated by replay samples drawn from all tasks. This globally beneficial gradient signal refines universal feature representations, improving performance across the entire task spectrum. The effect scales with the number of tasks: the mean per-task gain is $+0.042$ on CIFAR-10 (5 tasks) and $+0.073$ on CIFAR-100 (20 tasks), suggesting a rich-get-richer dynamic where more diverse replay signals produce stronger encoder improvements.

This finding raises important questions for future work: Can the positive transfer effect be amplified through targeted replay scheduling? Does it generalise to convolutional and transformer-based architectures? And can it be exploited deliberately as a knowledge consolidation mechanism?

8.3. Late Feature Transfer and Anomalous Gains

Several tasks—particularly Task 4 on CIFAR-100 ($+0.326$)—show post-healing accuracy that substantially exceeds the original post-training value. We hypothesise a late feature transfer effect: when a column is reinitialised and retrained with full lateral connections, it benefits from richer features in the shared encoder and adjacent columns than were available at original training time (when fewer columns existed). This controlled reinitialisation acts as a form of post-hoc knowledge distillation.

8.4. Threshold Sensitivity

The accuracy-drop threshold ${\delta }_{\mathrm{acc}}=0.10$ and PSI threshold ${\delta }_{\mathrm{PSI}}=0.25$ are operational heuristics motivated by preliminary validation and standard drift-monitoring practice [10]. Both thresholds are conservative: in all experiments, the induced accuracy drop ($\ge 0.374$) far exceeded ${\delta }_{\mathrm{acc}}$, ensuring detection with no false negatives. Adaptive thresholding is a natural direction for future work in settings with gradual drift.

8.5. Scalability

Parameter count grows linearly in T (Equation (8)). Healing cost is $O\left(\right|{\mathcal{R}}_t|·E_{\mathrm{heal}})$, independent of T. On CIFAR-100, healing 20 tasks required 10 retraining epochs over a 500-sample buffer—approximately 2.5% of the total original training budget. This makes PSHNN practical for moderate-length task sequences.

9. Limitations and Future Work

• Architecture scope.

Current experiments use MLP-based columns. Evaluation with convolutional and transformer-based backbones is needed to establish scalability to complex vision tasks.

• Linear parameter growth.

PSHNN grows one column per task. Column compression, pruning, or sharing strategies are required for very long task sequences.

• Data availability during healing.

The current protocol assumes that labelled replay data remain available. Unsupervised or weakly supervised healing is an important direction for privacy-constrained settings.

• Multi-column corruption.

Experiments corrupt a single column. The healing controller generalises trivially to simultaneous multi-column corruption (each trigger is evaluated independently), but empirical validation is deferred to future work.

• Future directions.

(1) Evaluation on Split-TinyImageNet and class-incremental benchmarks; (2) adaptive thresholding for gradual drift; (3) targeted replay scheduling to amplify positive transfer; (4) parameter-efficient column reuse and pruning; (5) unsupervised healing for data-scarce deployments.

10. Conclusions

This paper presented Progressive Self-Healing Neural Networks (PSHNN), a continual learning framework that unifies modular task expansion with autonomous fault recovery. By combining progressive columns with lateral transfer connections, per-task replay memory, and a dual-signal autonomic healing controller, PSHNN addresses both catastrophic forgetting and parameter corruption within a single coherent architecture.

Experiments on Split-MNIST, Split-CIFAR-10, and Split-CIFAR-100 demonstrate that PSHNN retains prior task knowledge, learns new tasks effectively, and fully recovers from simulated column corruption—in each case restoring mean accuracy to or above the pre-corruption baseline. A novel positive transfer effect during healing was identified and analysed: replay-driven encoder updates improve accuracy on unaffected prior tasks by a mean of $+0.042$ to $+0.073$ depending on benchmark complexity. Together, these results establish PSHNN as a principled and practically effective framework for resilient continual learning in non-stationary environments.