Chapter 28: Continual Learning and Model Updating Strategies
Learning Objectives
By the end of this chapter, readers will be able to:
- Understand the mathematical foundations of catastrophic forgetting and why it poses unique challenges in healthcare applications for underserved populations
- Implement and evaluate major continual learning approaches including regularization-based, replay-based, and architecture-based methods with comprehensive fairness monitoring
- Detect and respond to distribution shifts in clinical data while maintaining equitable performance across demographic groups
- Design governance frameworks for model evolution that ensure transparent communication with stakeholders and maintain trust in communities with historical healthcare marginalization
- Build production-ready continual learning systems that balance stability with adaptation while monitoring fairness metrics throughout the model lifecycle
- Navigate regulatory requirements for model updates in healthcare settings, including considerations for diverse populations and health equity
Introduction
Healthcare is fundamentally dynamic. Patient populations evolve as demographics shift, migration patterns change, and social determinants of health fluctuate. Clinical practices advance with new evidence, treatment protocols emerge, and diagnostic technologies improve. Disease presentations change with emerging pathogens, evolving antibiotic resistance, and environmental factors. For machine learning models deployed in healthcare settings, this dynamism presents a critical challenge: models trained on historical data inevitably become outdated, potentially degrading in performance and exacerbating health inequities if not properly maintained and updated.
Traditional machine learning assumes that training and deployment data are drawn from the same distribution, an assumption routinely violated in real-world healthcare applications. When this assumption breaks, model performance can degrade precipitously, and crucially, this degradation often occurs non-uniformly across demographic groups. A model trained primarily on data from well-resourced academic medical centers may perform adequately when first deployed but deteriorate more rapidly for patients from under-resourced community health centers as local practice patterns and patient populations evolve. A diagnostic algorithm developed before the COVID-19 pandemic may struggle with post-acute sequelae presentations that disproportionately affect certain racial and ethnic groups. An algorithm trained on paper-based clinical documentation may fail when applied to new electronic health record systems with different documentation practices, affecting populations transitioning to digital health infrastructure.
Continual learning, also termed lifelong learning or incremental learning, addresses these challenges by enabling models to adapt to new data and tasks while retaining previously acquired knowledge. However, implementing continual learning in healthcare requires careful consideration of unique domain constraints. Unlike computer vision or natural language processing benchmarks where catastrophic forgetting is primarily a technical nuisance, in healthcare the stakes involve patient safety, diagnostic accuracy, and equitable access to high-quality care. A model that “forgets” how to accurately diagnose rare presentations predominantly affecting specific ethnic minorities in favor of learning more common presentations in the general population is not merely technically suboptimal but ethically unacceptable and potentially harmful.
This chapter examines continual learning through the lens of health equity, addressing both the technical foundations and the sociotechnical considerations essential for responsible model updating in healthcare. We begin with the mathematical underpinnings of catastrophic forgetting and explore why neural networks exhibit this phenomenon. We then survey major continual learning paradigms, including regularization-based approaches that constrain parameter updates to preserve important knowledge, replay-based methods that maintain representative samples of historical data, and architectural approaches that dedicate model capacity to different tasks or time periods. Throughout, we emphasize fairness-aware continual learning that monitors and maintains equitable performance across demographic groups as models evolve.
Distribution shift presents a related but distinct challenge. We examine different types of shift common in healthcare data, from gradual covariate shift as patient demographics change to abrupt concept drift when treatment protocols are updated. We discuss detection mechanisms that can trigger model retraining and adaptation strategies that balance responsiveness to new patterns with stability on historical tasks. Critically, we address how distribution shift often manifests differently across demographic groups, with marginalized populations potentially experiencing more dramatic shifts due to changes in healthcare access, insurance coverage, or clinical practices.
Governance and versioning form the final major component of responsible continual learning systems. We explore model versioning strategies that enable rollback when updates degrade performance, A/B testing frameworks that allow careful evaluation before full deployment, and canary deployments that progressively roll out updates while monitoring for adverse effects. We discuss stakeholder communication strategies that build trust through transparency about model changes, particularly important for communities with historical reasons to distrust healthcare institutions. We address regulatory considerations, including how different update types may trigger different FDA requirements and how to document model evolution for audit and accountability.
The implementations throughout this chapter provide production-ready systems for continual learning with comprehensive fairness monitoring. We build complete pipelines for detecting distribution shift, triggering appropriate adaptation mechanisms, monitoring fairness metrics across demographic groups throughout model evolution, and maintaining transparent documentation of model changes. These implementations use realistic healthcare data scenarios, including missing data patterns common in under-resourced settings, multilingual clinical text, and demographic imbalances typical of real-world deployments.
The Problem of Catastrophic Forgetting
Catastrophic forgetting, also termed catastrophic interference, describes the tendency of neural networks to abruptly and dramatically lose previously learned information when trained on new tasks or data. This phenomenon was first systematically studied by McCloskey and Cohen in 1989, who demonstrated that connectionist networks could completely forget previously learned associations when trained on new patterns. French subsequently provided theoretical analysis showing that catastrophic forgetting arises from the distributed representation structure of neural networks, where information about different tasks or examples is stored in overlapping sets of weights.
Mathematical Foundations
Consider a neural network with parameters $\theta$ trained sequentially on a series of tasks $T_1, T_2, \ldots, T_n$. For each task $T_i$, we have a dataset $\mathcal{D}_i = \{(x_j^{(i)}, y_j^{(i)})\}_{j=1}^{N_i}$ and a loss function $\mathcal{L}_i(\theta)$. In traditional supervised learning, we would train on task $T_i$ by minimizing:
where $\ell$ is a loss function such as cross-entropy for classification or mean squared error for regression, and $f_\theta$ represents the neural network function parameterized by $\theta$.
When we subsequently train on task $T_{i+1}$, standard stochastic gradient descent updates the parameters according to:
where $\eta$ is the learning rate. The problem is that these updates are computed solely based on the loss for task $T_{i+1}$, with no explicit constraint to preserve performance on tasks $T_1, \ldots, T_i$. Because neural networks use distributed representations where the same parameters influence predictions across multiple tasks, updates optimized for $T_{i+1}$ can dramatically increase loss on previous tasks.
To quantify catastrophic forgetting, we measure the performance change on previous tasks after learning new tasks. Let $A_i(j)$ denote the accuracy on task $T_j$ after training on tasks $T_1, \ldots, T_i$. The average forgetting after learning task $T_n$ is:
This metric captures the maximum accuracy achieved on each task before learning subsequent tasks, minus the final accuracy after learning all tasks. High values of $\mathcal{F}_n$ indicate severe catastrophic forgetting.
The severity of catastrophic forgetting depends on several factors. Task similarity plays a crucial role: if tasks share common structure or representations, learning new tasks may benefit rather than harm performance on previous tasks through positive transfer. The degree of overlap in the optimal parameter configurations also matters: if $\theta_i^*$ and $\theta_j^*$ are similar for tasks $i$ and $j$, forgetting is less likely. Network capacity influences forgetting: larger networks with more parameters have greater ability to dedicate different subsets of parameters to different tasks, reducing interference. Finally, the learning rate and number of training epochs on new tasks affect the extent of parameter updates and thus the degree of forgetting.
Catastrophic Forgetting in Healthcare
In healthcare applications, catastrophic forgetting has particularly severe implications because medical knowledge accumulates over time and diagnostic accuracy on rare conditions may be critical even as overall case prevalence changes. Consider a diagnostic model for infectious diseases initially trained to recognize bacterial pneumonia, fungal infections, and tuberculosis. If this model is subsequently updated to recognize COVID-19 using data from 2020-2021 when COVID-19 was the dominant respiratory pathogen, standard training may cause the model to forget how to accurately diagnose tuberculosis, which became relatively less prevalent but remains a critical diagnosis, particularly in immigrant and refugee populations.
The health equity implications of catastrophic forgetting are profound. Rare conditions, presentations in atypical populations, and diseases disproportionately affecting marginalized groups are exactly those for which training data is limited. When a model is updated on new, more abundant data, these underrepresented categories are at highest risk of being forgotten. A model that forgets rare genetic disorders predominantly affecting specific ethnic populations, uncommon presentations of common diseases in older adults, or conditions primarily seen in unhoused populations effectively exacerbates health disparities by degrading care quality for already underserved groups.
Furthermore, the temporal dynamics of healthcare access mean that some populations may be systematically underrepresented in recent data even if they were reasonably represented in historical training data. Changes in insurance coverage, clinic closures, or shifts in healthcare-seeking behavior related to immigration enforcement or pandemic-related concerns can cause certain demographic groups to effectively disappear from new training data. Without explicit mechanisms to prevent catastrophic forgetting, model updates could eliminate the (perhaps imperfect) predictive capacity the model had for these populations.
Theoretical Analysis of Forgetting
Several theoretical frameworks help explain why neural networks exhibit catastrophic forgetting. The neural tangent kernel (NTK) theory provides one perspective. For infinitely wide neural networks in the lazy training regime, the network function evolves according to a kernel gradient descent in function space:
where $\Theta(x, x')$ is the neural tangent kernel defined as:
and $\mathcal{P}_0$ is the initialization distribution. In this regime, the network function at initialization plus its linear approximation around initialization parameters describes the network’s evolution during training. When training on a new task, the gradient updates are computed based only on the new task’s loss landscape, leading to changes in the function that can be destructive for previous tasks unless the neural tangent kernels for different tasks have specific structure that preserves previous performance.
An alternative perspective comes from mode connectivity and loss landscape analysis. Neural networks often have multiple local minima that achieve good performance on a given task. These minima are connected by low-loss paths or tunnels in parameter space, forming a complex loss landscape with multiple basins of attraction. When training on a new task, gradient descent moves the parameters toward minima for the new task, potentially crossing high-loss regions for previous tasks. If the minima for different tasks are in disconnected regions of parameter space, catastrophic forgetting is inevitable with standard sequential training.
Bayesian perspectives on continual learning model parameter uncertainty and update the posterior distribution over parameters as new data arrives. Let $p(\theta \mid \mathcal{D}_1)$ be the posterior after training on task 1. When task 2 data arrives, we should update:
This formulation naturally incorporates knowledge from previous tasks through the prior $p(\theta \mid \mathcal{D}_1)$. However, computing and maintaining exact posteriors is intractable for high-dimensional neural network parameter spaces, leading to the development of approximate Bayesian continual learning methods that we discuss in subsequent sections.
Regularization-Based Continual Learning
Regularization-based approaches to continual learning add penalty terms to the loss function that discourage large changes to parameters deemed important for previous tasks. The intuition is that if certain parameters were critical for good performance on earlier tasks, they should be preserved or changed minimally when learning new tasks. This approach balances the need to learn new information with the imperative to retain previous knowledge by explicitly trading off loss on the current task against changes to important parameters.
Elastic Weight Consolidation
Elastic Weight Consolidation (EWC), introduced by Kirkpatrick and colleagues in 2017, provides a principled Bayesian approach to identifying important parameters. EWC approximates the posterior distribution over parameters after learning previous tasks as a Gaussian centered at the optimal parameters $\theta_A^*$ for those tasks:
where $F_A$ is the Fisher information matrix evaluated at $\theta_A^*$:
The Fisher information matrix captures how sensitive the log-likelihood is to changes in each parameter. Parameters with high Fisher information are those for which small changes cause large changes in the likelihood, indicating these parameters are important for the task.
When learning a new task $B$, EWC adds a regularization term that penalizes changes to parameters weighted by their Fisher information:
where $\lambda$ controls the relative importance of the regularization term. Parameters with high Fisher information are strongly constrained to remain close to their values after training on previous tasks, while parameters with low Fisher information can change freely to accommodate the new task.
The Fisher information matrix is typically intractable to compute exactly for large neural networks, as it requires computing second derivatives of the log-likelihood. EWC uses an efficient diagonal approximation:
This diagonal approximation assumes independence between parameters, which is clearly an approximation for neural networks where parameters interact through nonlinear activations. Nevertheless, empirical results show this approximation provides effective regularization in practice.
For continual learning across multiple tasks $T_1, T_2, \ldots, T_n$, we can accumulate Fisher information matrices across tasks. After learning task $T_k$, we compute $F_k$ and store it along with $\theta_k^*$. When learning task $T_{k+1}$, the loss becomes:
This formulation can lead to memory issues as we must store Fisher information matrices and optimal parameters for all previous tasks. Online EWC addresses this by maintaining a single cumulative Fisher information matrix that is updated as new tasks arrive, sacrificing some theoretical rigor for practical scalability.
Synaptic Intelligence
Synaptic Intelligence (SI), proposed by Zenke, Poole, and Ganguli in 2017, takes a different approach to identifying important parameters. Rather than using Fisher information computed at the end of training on each task, SI tracks the importance of each parameter throughout the learning trajectory by accumulating path integrals of gradients.
The contribution of parameter $\theta_i$ to reducing the loss on task $k$ over the learning trajectory is:
where $g_i^{(k)}(t)$ is the gradient of the loss for task $k$ with respect to parameter $i$ at time step $t$, and $\Delta \theta_i(t) = \theta_i(t+1) - \theta_i(t)$ is the parameter change at that time step. This quantity measures how much each parameter contributed to loss reduction: parameters that move in the direction of the negative gradient contribute positively to $\omega_i^{(k)}$.
To prevent numerical issues and ensure scale invariance, SI normalizes these contributions by the total parameter change:
where $\Delta \theta_i^{(k)} = \theta_i^{(k+1)} - \theta_i^{(k)}$ is the total change in parameter $i$ during training on task $k$, and $\xi$ is a small damping parameter for numerical stability.
When learning task $k+1$, SI adds a quadratic penalty on parameter changes weighted by these importance measures:
Similar to EWC, this encourages parameters that were important for previous tasks to change minimally when learning new tasks. Unlike EWC, SI computes importance based on the actual contribution of parameters during training rather than curvature of the loss surface at the final parameters, potentially providing a more direct measure of parameter importance.
Memory Aware Synapses
Memory Aware Synapses (MAS), introduced by Aljundi and colleagues in 2018, estimates parameter importance based on the sensitivity of the learned function output to parameter changes rather than sensitivity of the loss. The importance of parameter $\theta_i$ is defined as:
This measures how much the network’s output changes when parameter $i$ changes, averaged over the data distribution. Parameters that strongly influence the output are deemed important and should be preserved during subsequent learning.
A key advantage of MAS is that it does not require task labels during continual learning. While EWC and SI compute importance with respect to specific tasks, MAS computes importance based on the learned function itself, making it applicable in scenarios where task boundaries are not clearly defined or where continual learning occurs in a task-free streaming data setting.
Practical Considerations for Healthcare
When applying regularization-based continual learning in healthcare, several practical considerations arise. First, the choice of regularization strength $\lambda$ critically affects the stability-plasticity tradeoff. High values of $\lambda$ strongly preserve previous knowledge but limit the model’s ability to adapt to new patterns. Low values allow greater plasticity but risk catastrophic forgetting. In healthcare, this tradeoff has direct implications for patient safety: too much stability may prevent the model from learning important new clinical patterns, while too much plasticity may cause the model to forget rare but critical diagnoses.
Second, computational costs must be considered. Computing Fisher information matrices, path integrals of gradients, or output sensitivities all add overhead to the training process. For large models commonly used in medical imaging or clinical NLP, these computations can be substantial. Efficient approximations, such as diagonal Fisher information matrices or sampling-based estimation, become necessary for practical deployment.
Third, the assumption that important parameters can be identified through local curvature or gradient information may not hold uniformly across demographic groups. If certain populations are underrepresented in the data used to compute parameter importance, parameters crucial for predicting outcomes in those populations may be incorrectly identified as unimportant. This could lead to disproportionate forgetting for minority groups. Stratified computation of importance measures across demographic groups can help address this concern.
Finally, healthcare applications often involve multiple interdependent tasks rather than clearly separated sequential tasks. A model may need to simultaneously maintain performance on diabetes prediction for multiple ethnic groups, age ranges, and insurance types while learning to incorporate new biomarkers or screening protocols. This multi-task continual learning setting requires careful design of regularization schemes that consider the complex structure of healthcare prediction tasks.
Replay-Based Continual Learning
Replay-based approaches to continual learning maintain a memory buffer containing representative samples from previous tasks or data distributions. When training on new data, the model is trained jointly on the new data and samples from the memory buffer, effectively interleaving new learning with rehearsal of old knowledge. This approach draws inspiration from systems consolidation in neuroscience, where the brain repeatedly reactivates and replays experiences to transfer information from hippocampus to neocortex for long-term storage.
Experience Replay
Experience Replay, widely used in reinforcement learning and adapted for continual supervised learning, maintains a memory buffer $\mathcal{M}$ containing $(x, y)$ pairs from previous tasks. When learning from new data $\mathcal{D}_{new}$, the model is trained on batches that combine new samples with samples randomly drawn from $\mathcal{M}$:
where $\alpha$ controls the relative weight of replayed samples. This approach ensures that the model maintains exposure to previous data distributions throughout training on new tasks, preventing the parameter updates from being driven solely by the new task.
The critical design decision in experience replay is the memory management strategy: how to select which samples to store when memory capacity is limited, and how to update the memory as new tasks arrive. Several strategies exist:
Reservoir Sampling: Maintains a uniform sample over all observed data by probabilistically replacing older samples. When a new sample arrives, it is added to the memory with probability $\frac{\lvert \mathcal{M} \rvert}{n}$ where $n$ is the total number of samples seen, and if added, it randomly replaces an existing sample. This ensures each historical sample has equal probability of being in memory regardless of when it was observed.
Herding: Selects samples that best represent the feature distribution of each class or task. For a given class $c$, herding maintains a memory set $\mathcal{M}_c$ such that the mean feature representation of samples in $\mathcal{M}_c$ is close to the mean feature representation of all samples of class $c$:
where $\phi(x)$ represents the feature embedding of sample $x$ (typically the penultimate layer activations of the neural network), and $m$ is the memory budget per class.
Ring Buffer: Simply stores the most recent samples in a first-in-first-out manner. While this approach does not maintain a representative sample of the entire historical distribution, it can be effective when the data distribution changes gradually and recent samples are most relevant.
Class-Balanced Sampling: Ensures equal representation of all classes in memory regardless of their prevalence in the data stream. This is particularly important for healthcare applications where rare diagnoses or underrepresented populations may be overwhelmed by common cases if sampling is purely proportional to prevalence.
Gradient-Based Sample Selection
More sophisticated replay methods select memory samples based on their utility for preserving model performance. Gradient Episodic Memory (GEM), introduced by Lopez-Paz and Ranzato, formulates continual learning as a constrained optimization problem. When learning task $t$, GEM ensures that gradient updates do not increase the loss on previous tasks:
[
\begin{aligned}
\min_{\theta} \quad & \mathcal{L}t(\theta)
\text{subject to} \quad & \mathcal{L}_k(\theta) \leq \mathcal{L}_k(\theta{t-1}) \quad \forall k < t
\end{aligned}
]
In practice, this is enforced by checking whether the gradient on the current task $g_t = \nabla_\theta \mathcal{L}_t(\theta)$ increases any previous task loss. If so, the gradient is projected to the nearest direction that does not increase previous task losses:
where $g_k = \nabla_\theta \mathcal{L}_k(\theta)$ is the gradient on task $k$ computed using samples from memory. This projection can be efficiently computed using quadratic programming.
Averaged GEM (A-GEM) provides a more scalable variant by enforcing only that the gradient does not increase the average loss across previous tasks rather than enforcing constraints for each task individually. This reduces the computational complexity from quadratic to linear in the number of tasks.
Generative Replay
Generative replay addresses memory constraints by training a generative model to produce synthetic samples representative of previous data distributions rather than storing actual data samples. When learning task $t$, a generative model $G_t$ (such as a variational autoencoder or generative adversarial network) is trained alongside the main model to generate samples resembling task $t$ data. When learning subsequent tasks, synthetic samples from $G_t$ are used for replay instead of actual stored samples.
The loss function for generative replay combines the current task loss with a replay loss on generated samples:
Note that for generated samples, the labels come from the model’s own predictions at the end of training on task $k$. This is necessary because the generator only produces input features, not labels. The model effectively trains to match its previous predictions on synthetic data from old tasks while learning new patterns from new task data.
Generative replay has several advantages: it eliminates privacy concerns about storing actual patient data, it removes hard memory constraints since generators can produce unlimited samples, and it can potentially generate more diverse samples than a fixed memory buffer. However, it also has limitations: generators must be high-quality to produce useful replay samples, generator training adds computational overhead, and generated samples may not capture the full complexity of the original data distribution, particularly for high-dimensional medical imaging data.
Fairness Considerations in Replay
For healthcare applications serving diverse populations, replay-based continual learning raises critical fairness considerations. The memory buffer must adequately represent all demographic groups, not just the majority population. Simple random sampling or most-recent sampling can lead to underrepresentation of minority groups, effectively allowing the model to forget patterns specific to these populations.
Several strategies can promote fairness in replay:
Stratified Sampling: Explicitly allocates memory budget proportionally or equally across demographic strata. For example, if the memory budget is 1000 samples and we have 5 racial/ethnic groups, we might allocate 200 samples to each group regardless of their prevalence in the overall data. This ensures minority groups have sufficient representation in memory even when they constitute small fractions of the data.
Importance-Weighted Sampling: Assigns higher sampling probabilities to underrepresented groups or to samples that are particularly informative for maintaining fairness metrics. This can be formalized by computing sample importance based on contribution to group-specific fairness measures.
Fairness-Preserving Herding: Extends herding to consider demographic group representations alongside class distributions. The objective becomes minimizing the distance between the feature distribution of each class-demographic group combination in memory versus the original data:
where $\mu_{c,d}^{\mathcal{D}}$ and $\mu_{c,d}^{\mathcal{S}}$ are mean feature representations for class $c$ and demographic group $d$ in the full dataset and memory set respectively, and $w_{c,d}$ are weights emphasizing rare class-demographic combinations.
Multi-Objective Replay: Formulates replay sample selection as a multi-objective optimization problem balancing overall accuracy preservation with fairness metric preservation across groups. Pareto optimization techniques can identify memory sets that provide reasonable tradeoffs across these potentially competing objectives.
For generative replay, ensuring fairness requires training demographic-group-specific generators or conditioning a single generator on demographic attributes. Without explicit conditioning, generative models trained on imbalanced data often reproduce or amplify that imbalance, generating synthetic samples predominantly from majority groups and failing to preserve minority group representations.
Architecture-Based Continual Learning
Architecture-based approaches to continual learning allocate dedicated model capacity to different tasks or time periods, eliminating interference between tasks by ensuring they use different parameters. While this requires growing model capacity over time, it provides strong guarantees against catastrophic forgetting and can be combined with compression techniques to manage model size.
Progressive Neural Networks
Progressive Neural Networks, introduced by Rusu and colleagues in 2016, create a separate neural network column for each task while retaining lateral connections from previous columns to enable transfer learning. When learning task $t$, a new column of layers is instantiated with random initialization. Each layer in the new column receives input not only from the previous layer in its own column but also from corresponding layers in all previous columns through lateral connections.
Formally, the activation $h_i^{(t)}$ at layer $i$ for task $t$ is:
where $W_i^{(t)}$ are the within-column weights for task $t$, $U_i^{(k \rightarrow t)}$ are lateral connection weights from column $k$ to column $t$, and $\sigma$ is a nonlinearity. The lateral connections allow new tasks to leverage features learned for previous tasks while the dedicated columns ensure that learning new tasks does not modify parameters used by previous tasks.
Progressive networks completely eliminate catastrophic forgetting since parameters for old tasks are frozen after training. However, they suffer from unbounded growth in model size and parameters as more tasks are learned. For a network with $L$ layers and $n$ units per layer, learning $T$ tasks requires $O(T^2 L n^2)$ total parameters due to the lateral connections from all previous columns to each new column.
Packnet
PackNet, developed by Mallya and Lazebnik, addresses the growth problem by iteratively pruning and retraining networks to pack multiple tasks into a single model. The algorithm proceeds in three steps for each new task:
- Training: Train the full network on the new task using standard supervised learning
- Pruning: Identify and prune weights that are least important for all tasks learned so far, creating free capacity
- Fine-tuning: Retrain the network with pruned weights fixed at zero and only active weights trainable
The pruning step uses magnitude-based pruning, setting weights below a threshold to zero. The threshold is chosen to achieve a target sparsity level. Importance is assessed globally across all tasks: weights that are important for any task are retained. This is implemented by tracking which weights are active (non-zero) after pruning for each task and taking the union of active weight sets.
When learning task $t$, let $M^{(k)}$ be the binary mask of active weights for task $k$. The combined mask $M^{(1:t-1)} = M^{(1)} \vee M^{(2)} \vee \cdots \vee M^{(t-1)}$ indicates weights used by any previous task. During training on task $t$, only weights where $M^{(1:t-1)} = 0$ are updated, ensuring previous task parameters remain unchanged.
PackNet can continue learning new tasks until the network reaches full capacity (all weights are being used by some task). In practice, with deep networks and high sparsity levels (e.g., 50-80% of weights pruned per task), PackNet can accommodate many tasks before exhausting capacity. However, unlike progressive networks, there is no theoretical guarantee of unlimited task capacity, and performance may degrade as the network approaches full capacity.
Dynamically Expandable Networks
Dynamically Expandable Networks (DEN), proposed by Yoon and colleagues, selectively expand network capacity only when necessary rather than growing with every new task. DEN uses three mechanisms to manage capacity:
Selective Retraining: When learning a new task, DEN first attempts to fine-tune existing parameters. It identifies which neurons are important for previous tasks using a group sparsity regularizer and freezes those neurons while allowing other neurons to be retrained for the new task.
Dynamic Network Expansion: If selective retraining does not achieve sufficient performance on the new task (measured by validation accuracy), DEN dynamically adds new neurons to the network. The number of neurons added is determined adaptively based on the performance gap.
Network Split/Duplication: When neurons are used by multiple tasks and cause interference, DEN duplicates those neurons to create task-specific versions, reducing negative transfer while maintaining parameter efficiency.
The selective retraining phase minimizes:
where the first regularization term preserves important parameters, and the second group sparsity term encourages entire neurons to be either active or inactive, facilitating clear task assignment.
The expansion phase adds neurons with proper initialization to ensure they can effectively learn the new task without disrupting existing knowledge. New neurons are initialized based on the distribution of activations on the new task data, ensuring they operate in a suitable range for learning.
DEN provides a middle ground between progressive networks (which always expand) and PackNet (which never expands): capacity grows only when necessary, leading to more compact models than progressive networks while avoiding the hard capacity constraints of PackNet.
Continual Learning with Hypernetworks
Recent work has explored using hypernetworks—networks that generate weights for other networks—for continual learning. The hypernetwork is conditioned on task embeddings and generates task-specific weights for a main network. When learning a new task, the hypernetwork parameters are updated while previously generated weights remain fixed.
Let $h_\phi$ be the hypernetwork parameterized by $\phi$, and let $e_t$ be an embedding vector for task $t$. The weights for task $t$ are generated as:
When learning task $t$, we optimize:
where $f_{\theta_t}$ is the main network with weights $\theta_t$. Previously learned task embeddings $e_1, \ldots, e_{t-1}$ are frozen, so previous task weights $\theta_1, \ldots, \theta_{t-1}$ remain unchanged.
Hypernetwork-based continual learning provides several advantages: it explicitly separates task-specific knowledge (in the task embeddings) from shared knowledge (in the hypernetwork), it allows tasks to share structure through the hypernetwork while maintaining task-specific parameters, and it can potentially generalize to new tasks through interpolation in embedding space. However, it requires defining task embeddings and assumes task identities are known during training and inference.
Practical Considerations for Healthcare
Architecture-based continual learning methods face specific challenges in healthcare applications. First, many healthcare prediction tasks are not cleanly separable into discrete tasks but rather involve gradual distribution shift over time or overlapping tasks (e.g., predicting multiple related outcomes for diverse patient populations). This complicates approaches like progressive neural networks that assume clear task boundaries.
Second, deployment constraints in healthcare may limit the size and complexity of models. Progressive neural networks’ unbounded growth may be unacceptable for resource-constrained settings like community health centers or mobile health applications. Similarly, the computational overhead of dynamically growing networks during deployment may be infeasible when models need to provide real-time predictions.
Third, regulatory requirements for medical devices may require revalidation when model architectures change. Adding neurons or layers to an FDA-cleared algorithm may trigger requirements for new 510(k) submissions, creating regulatory barriers to adaptive architectures that grow during deployment.
Finally, fairness considerations emerge when allocating capacity to different tasks or time periods. If new capacity is added primarily when learning from data-rich populations or common conditions while minority groups or rare diseases receive less new capacity, this effectively prioritizes majority group performance. Capacity allocation strategies that explicitly consider performance across demographic groups can help ensure equitable adaptation.
Distribution Shift and Adaptation
Healthcare data is subject to numerous sources of distribution shift that can degrade model performance over time. Understanding the types of shift, detecting when they occur, and adapting models appropriately while maintaining fairness are critical for deploying reliable continual learning systems in clinical practice.
Types of Distribution Shift
Distribution shift can be taxonomized into several categories based on what aspects of the data generation process change:
Covariate Shift: The input distribution $P(X)$ changes while the conditional distribution of outputs given inputs $P(Y\mid X)$ remains constant. In healthcare, covariate shift might occur when the demographic composition of a patient population changes due to migration patterns or changes in insurance coverage, but the relationship between patient features and clinical outcomes remains stable. Formally:
Label Shift: The marginal distribution of outputs $P(Y)$ changes while the conditional distribution of inputs given outputs $P(X\mid Y)$ remains constant. This might occur when disease prevalence changes (e.g., seasonal variation in influenza, emergence of new pathogens like COVID-19) but the characteristic presentations of diseases remain stable. Formally:
Concept Drift: The fundamental relationship between inputs and outputs $P(Y\mid X)$ changes. This is the most challenging type of shift as it indicates the underlying phenomena being modeled have changed. In healthcare, concept drift occurs when treatment protocols change, new therapies become available, or the causal pathways linking risk factors to outcomes change. For example, the relationship between blood pressure and cardiovascular risk changed with the introduction of modern antihypertensive medications. Formally:
Domain Shift: More generally, the entire joint distribution $P(X, Y)$ changes, which may involve combinations of the above. Electronic health record systems often experience domain shift when transitioning from one documentation system to another, changing both the feature distributions and potentially the relationships between features and outcomes.
These shifts can occur gradually over time (gradual drift) or abruptly at specific time points (sudden drift or concept shift). Gradual drift is common when underlying populations slowly evolve, while sudden drift often results from discrete events like policy changes, system implementations, or public health emergencies.
Equity Implications of Distribution Shift
Distribution shift often manifests differently across demographic groups, with underserved populations particularly vulnerable to dramatic shifts. Changes in healthcare access, insurance coverage, or clinical practice patterns may affect marginalized communities more severely than majority populations. For instance, changes in Medicaid eligibility can cause abrupt shifts in the patient population at safety-net hospitals, while academic medical centers primarily serving privately insured patients experience smaller changes.
Furthermore, models may adapt differently to shifts in different populations. If drift detection algorithms are calibrated on majority populations, they may fail to detect shifts primarily affecting minority groups. If adaptation is triggered only when aggregate performance degrades beyond some threshold, minority group performance may deteriorate substantially before adaptation occurs. These dynamics can cause initially fair models to become increasingly biased over time even when continual learning mechanisms are in place.
Shift Detection
Detecting distribution shift is the first step in adaptive continual learning. Numerous methods exist for shift detection, differing in what they measure, what data they require, and what types of shift they can detect.
Statistical Tests on Input Distributions: Compare the distribution of input features between training and deployment time. The Maximum Mean Discrepancy (MMD) test is commonly used, measuring the distance between distribution embeddings in a reproducing kernel Hilbert space:
For a finite sample, MMD can be computed as:
where $k$ is a kernel function, $\{x_i\}$ are training samples, and $\{x_i'\}$ are deployment samples. A permutation test establishes significance: if MMD between training and deployment is larger than most values obtained by randomly permuting labels, we conclude distribution shift has occurred.
Classifier-Based Shift Detection: Train a binary classifier to distinguish training data from deployment data. If the classifier achieves accuracy significantly better than random (0.5 for balanced classes), this indicates distribution shift. The classifier’s accuracy provides a measure of shift magnitude. This approach can detect both covariate shift and label shift depending on what features are provided to the classifier.
Performance Monitoring: Track model performance metrics on held-out validation data or newly arrived data with labels (when available). Sudden drops in accuracy, AUC, or other metrics indicate shift. However, this requires ground truth labels at deployment time, which may not be immediately available in healthcare settings due to delays in diagnosis confirmation or outcome ascertainment.
Prediction Uncertainty: Monitor changes in the model’s prediction uncertainty over time. Increased uncertainty may indicate the model is encountering data unlike what it was trained on. For Bayesian neural networks or ensembles, we can track the variance of predictions across ensemble members or posterior samples. For standard neural networks, calibration-aware metrics like the expected calibration error can indicate when the model’s confidence is becoming miscalibrated.
Drift-Specific Statistics: For specific types of shift, specialized statistics exist. For covariate shift, we can estimate the likelihood ratio $w(x) = \frac{P_{deploy}(x)}{P_{train}(x)}$ using probabilistic classifiers or density ratio estimation and monitor the distribution of $w(x)$ over time. For label shift, we can estimate changes in label prevalence using confusion matrices and the method of moments.
In healthcare, shift detection should be stratified by demographic groups to ensure shifts affecting minority populations are not masked by aggregate statistics. For each demographic group, we can compute separate shift detection statistics and trigger adaptation when shift is detected in any group, even if aggregate shift is not significant.
Adaptation Strategies
Once shift is detected, several strategies exist for adapting models:
Full Retraining: Retrain the model from scratch on recent data. This provides the strongest adaptation but completely discards historical knowledge, risking catastrophic forgetting of patterns no longer well-represented in recent data. Full retraining is most appropriate when concept drift is suspected (the fundamental relationships have changed) and when sufficient recent data exists to learn all necessary patterns.
Fine-Tuning: Continue training the existing model on recent data using a lower learning rate than initial training. Fine-tuning provides a middle ground between full retraining and no adaptation, updating the model to capture new patterns while largely preserving existing knowledge encoded in the weights. However, without explicit mechanisms to prevent forgetting, fine-tuning can still suffer catastrophic forgetting, particularly if the new data distribution is substantially different from the training distribution.
Ensemble Updating: Maintain an ensemble of models trained on different time periods or data distributions. When shift is detected, add a new model trained on recent data to the ensemble and potentially remove the oldest model to manage ensemble size. Ensemble predictions can be weighted based on recency or performance on recent validation data. This approach naturally maintains representations of multiple distributions but increases computational costs and complexity.
Importance Weighting: Reweight training samples to account for covariate shift. If we can estimate the likelihood ratio $w(x) = \frac{P_{deploy}(x)}{P_{train}(x)}$, we can train or adapt models using the weighted loss:
This effectively emphasizes training samples that are more representative of the deployment distribution. Importance weighting is most effective for pure covariate shift but can be combined with other methods when multiple types of shift occur simultaneously.
Hybrid Approaches: Combine continual learning mechanisms (EWC, replay, etc.) with retraining on recent data. For example, when shift is detected, trigger fine-tuning with EWC regularization to adapt to new patterns while explicitly preserving important parameters for historical patterns. Or initiate retraining on a combination of replay memory and recent data, with replay memory stratified to ensure adequate representation of all demographic groups.
The choice of adaptation strategy should depend on the type and magnitude of shift, the availability of labeled data, computational constraints, and fairness considerations. Healthcare-specific considerations include regulatory requirements (some adaptation strategies may require revalidation), the clinical consequences of forgetting (inability to diagnose rare conditions may be unacceptable even if aggregate metrics improve), and the need for transparent communication with clinicians and patients about model updates.
Fairness-Aware Adaptation
Adapting models in response to distribution shift while maintaining fairness requires explicit monitoring of group-specific performance and shift detection. Key principles include:
Stratified Shift Detection: Compute shift detection statistics separately for each demographic group and trigger adaptation when shift is detected in any group, even if aggregate shift is not significant. This prevents minority group shifts from being masked by majority group stability.
Group-Specific Adaptation: When possible, adapt the model separately for different demographic groups. This might involve training group-specific components (e.g., separate output layers for different groups while sharing lower layers) or learning group-specific adjustments to a shared model. However, this approach requires sufficient data for each group and careful validation to ensure group-specific components do not encode sensitive attributes inappropriately.
Fairness-Constrained Retraining: When retraining or fine-tuning, impose fairness constraints that ensure disparities in performance or error rates across groups do not increase. This can be formulated as constrained optimization:
[
\begin{aligned}
\min_{\theta} \quad & \mathcal{L}(\theta)
\text{subject to} \quad & \Delta_{FPR}(\theta) \leq \epsilon_1
& \Delta_{FNR}(\theta) \leq \epsilon_2
\end{aligned}
]
where $\Delta_{FPR}(\theta)$ and $\Delta_{FNR}(\theta)$ measure disparities in false positive and false negative rates across groups, and $\epsilon_1, \epsilon_2$ are tolerance thresholds.
Fairness Auditing After Adaptation: After any model update, comprehensively audit fairness metrics stratified by demographic groups before deploying the updated model. Establish go/no-go criteria: the updated model should not degrade performance for any demographic group beyond acceptable thresholds, and fairness metrics should not worsen beyond acceptable bounds. If the updated model fails these criteria, either continue adaptation with modified strategies or revert to the previous model while investigating the source of fairness degradation.
Multi-Objective Adaptation: Formulate adaptation as a multi-objective optimization problem balancing overall performance, stability (minimizing forgetting), and fairness across groups. Pareto optimization or weighted combinations of objectives can identify adaptation strategies that achieve reasonable tradeoffs.
Implementation
We now implement a complete continual learning system for healthcare with comprehensive fairness monitoring throughout the adaptation process.
"""
Production-Ready Continual Learning System for Healthcare
Implements EWC, experience replay, and fairness-aware adaptation
"""
import numpy as np
from typing import Dict, List, Tuple, Optional, Any, Callable
from dataclasses import dataclass, field
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader, TensorDataset
from sklearn.metrics import roc_auc_score, accuracy_score, confusion_matrix
from collections import deque, defaultdict
import logging
import json
from datetime import datetime
from scipy import stats
import warnings
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
@dataclass
class ContinualLearningConfig:
"""Configuration for continual learning system."""
# Memory and replay
memory_size: int = 1000
replay_batch_fraction: float = 0.3
memory_selection_strategy: str = 'stratified' # 'random', 'stratified', 'herding'
# EWC parameters
ewc_lambda: float = 1000.0
fisher_estimation_samples: int = 500
# Shift detection
shift_detection_window: int = 100
shift_detection_threshold: float = 0.05
use_mmd_test: bool = True
# Fairness monitoring
sensitive_attributes: List[str] = field(default_factory=lambda: ['race', 'sex', 'age_group'])
fairness_threshold: Dict[str, float] = field(default_factory=lambda: {
'demographic_parity_difference': 0.1,
'equalized_odds_difference': 0.1,
'accuracy_disparity': 0.05
})
# Adaptation
adaptation_strategy: str = 'ewc_replay' # 'full_retrain', 'fine_tune', 'ewc_replay'
adaptation_epochs: int = 5
adaptation_lr: float = 0.0001
# Validation
validation_fraction: float = 0.2
min_group_size: int = 30
class MemoryBuffer:
"""
Memory buffer for experience replay with fairness-aware sampling.
Maintains representative samples from historical data with stratification
by demographic groups to ensure equitable replay.
"""
def __init__(
self,
max_size: int,
selection_strategy: str = 'stratified',
sensitive_attributes: Optional[List[str]] = None
):
"""
Initialize memory buffer.
Args:
max_size: Maximum number of samples to store
selection_strategy: Strategy for selecting samples ('random', 'stratified', 'herding')
sensitive_attributes: List of sensitive attributes for stratification
"""
self.max_size = max_size
self.selection_strategy = selection_strategy
self.sensitive_attributes = sensitive_attributes or []
self.data: List[Dict[str, Any]] = []
self.current_size = 0
# Track group counts for stratified sampling
self.group_counts: Dict[Tuple, int] = defaultdict(int)
def add_batch(
self,
features: np.ndarray,
labels: np.ndarray,
metadata: Dict[str, np.ndarray]
) -> None:
"""
Add a batch of samples to memory.
Args:
features: Feature array of shape (n_samples, n_features)
labels: Label array of shape (n_samples,)
metadata: Dictionary of metadata arrays including sensitive attributes
"""
n_samples = features.shape[0]
for i in range(n_samples):
sample = {
'features': features[i],
'label': labels[i],
'metadata': {key: val[i] for key, val in metadata.items()}
}
if self.selection_strategy == 'stratified':
self._add_stratified(sample)
else:
self._add_random(sample)
def _add_random(self, sample: Dict[str, Any]) -> None:
"""Add sample using reservoir sampling."""
if self.current_size < self.max_size:
self.data.append(sample)
self.current_size += 1
else:
# Reservoir sampling: replace with probability proportional to 1/n
idx = np.random.randint(0, self.current_size + 1)
if idx < self.max_size:
self.data[idx] = sample
self.current_size += 1
def _add_stratified(self, sample: Dict[str, Any]) -> None:
"""
Add sample using stratified sampling to ensure group representation.
"""
# Extract group identifier
group_key = tuple(
sample['metadata'].get(attr, 'unknown')
for attr in self.sensitive_attributes
)
if len(self.data) < self.max_size:
# Still filling buffer
self.data.append(sample)
self.group_counts[group_key] += 1
else:
# Buffer full - use stratified replacement
# Find group with highest count
max_group = max(self.group_counts.items(), key=lambda x: x[1])[0]
# If current sample is from underrepresented group or random chance
if group_key != max_group or np.random.random() < 0.5:
# Find sample from overrepresented group to replace
for i, stored_sample in enumerate(self.data):
stored_group = tuple(
stored_sample['metadata'].get(attr, 'unknown')
for attr in self.sensitive_attributes
)
if stored_group == max_group:
self.data[i] = sample
self.group_counts[max_group] -= 1
self.group_counts[group_key] += 1
break
def _add_herding(
self,
sample: Dict[str, Any],
feature_extractor: Callable[[np.ndarray], np.ndarray]
) -> None:
"""
Add sample using herding to maintain representative feature distribution.
Args:
sample: Sample to add
feature_extractor: Function to extract features for computing means
"""
# Extract features for current sample
features = feature_extractor(sample['features'][np.newaxis, :])[0]
# Extract group identifier
group_key = tuple(
sample['metadata'].get(attr, 'unknown')
for attr in self.sensitive_attributes
)
# Compute mean feature vector for this group
group_samples = [
s for s in self.data
if tuple(s['metadata'].get(attr, 'unknown') for attr in self.sensitive_attributes) == group_key
]
if not group_samples or len(self.data) < self.max_size:
self.data.append(sample)
self.group_counts[group_key] += 1
else:
# Compute current mean
group_features = np.array([
feature_extractor(s['features'][np.newaxis, :])[0]
for s in group_samples
])
current_mean = group_features.mean(axis=0)
# Compute mean if we add new sample
new_mean = (current_mean * len(group_samples) + features) / (len(group_samples) + 1)
# Find sample in memory whose removal brings us closest to desired mean
best_idx = None
best_distance = float('inf')
for i, stored_sample in enumerate(self.data):
stored_group = tuple(
stored_sample['metadata'].get(attr, 'unknown')
for attr in self.sensitive_attributes
)
if stored_group == group_key:
# Compute mean if we remove this sample and add new sample
stored_features = feature_extractor(
stored_sample['features'][np.newaxis, :]
)[0]
hypothetical_mean = (
(current_mean * len(group_samples) - stored_features + features) /
len(group_samples)
)
distance = np.linalg.norm(hypothetical_mean - new_mean)
if distance < best_distance:
best_distance = distance
best_idx = i
if best_idx is not None:
self.data[best_idx] = sample
def sample(self, batch_size: int) -> Tuple[np.ndarray, np.ndarray, Dict[str, np.ndarray]]:
"""
Sample a batch from memory.
Args:
batch_size: Number of samples to draw
Returns:
Tuple of (features, labels, metadata)
"""
if not self.data:
raise ValueError("Memory buffer is empty")
# Sample with replacement if batch_size > buffer size
indices = np.random.choice(len(self.data), size=min(batch_size, len(self.data)), replace=False)
samples = [self.data[i] for i in indices]
features = np.stack([s['features'] for s in samples])
labels = np.array([s['label'] for s in samples])
metadata = {}
if samples[0]['metadata']:
for key in samples[0]['metadata'].keys():
metadata[key] = np.array([s['metadata'][key] for s in samples])
return features, labels, metadata
def get_group_statistics(self) -> Dict[Tuple, int]:
"""Get sample counts by demographic group."""
return dict(self.group_counts)
class FisherInformationMatrix:
"""
Diagonal Fisher Information Matrix for Elastic Weight Consolidation.
Approximates parameter importance by accumulating squared gradients
of the log-likelihood at optimal parameters.
"""
def __init__(self, model: nn.Module):
"""
Initialize Fisher information computation.
Args:
model: Neural network model
"""
self.model = model
self.fisher: Dict[str, torch.Tensor] = {}
self.optimal_params: Dict[str, torch.Tensor] = {}
def compute_fisher(
self,
dataloader: DataLoader,
num_samples: Optional[int] = None
) -> None:
"""
Compute diagonal Fisher information matrix.
Args:
dataloader: DataLoader with samples for Fisher computation
num_samples: Optional limit on number of samples to use
"""
self.fisher = {}
# Initialize Fisher dictionary
for name, param in self.model.named_parameters():
if param.requires_grad:
self.fisher[name] = torch.zeros_like(param)
self.model.eval()
samples_processed = 0
for batch_idx, (features, labels) in enumerate(dataloader):
if num_samples and samples_processed >= num_samples:
break
features = features.float()
labels = labels.float()
# Forward pass
outputs = self.model(features)
# For classification, compute log probability of correct class
if outputs.shape[1] == 1:
# Binary classification
log_probs = F.binary_cross_entropy_with_logits(
outputs.squeeze(),
labels,
reduction='sum'
)
else:
# Multi-class classification
log_probs = F.cross_entropy(outputs, labels.long(), reduction='sum')
# Backward pass to get gradients
self.model.zero_grad()
log_probs.backward()
# Accumulate squared gradients
for name, param in self.model.named_parameters():
if param.requires_grad and param.grad is not None:
self.fisher[name] += param.grad.data ** 2
samples_processed += features.shape[0]
# Average over samples
for name in self.fisher:
self.fisher[name] /= samples_processed
# Store current parameters as optimal
for name, param in self.model.named_parameters():
if param.requires_grad:
self.optimal_params[name] = param.data.clone()
logger.info(f"Computed Fisher information from {samples_processed} samples")
def ewc_loss(self, lambda_: float = 1000.0) -> torch.Tensor:
"""
Compute EWC regularization loss.
Args:
lambda_: Regularization strength
Returns:
EWC loss penalizing changes to important parameters
"""
loss = torch.tensor(0.0)
for name, param in self.model.named_parameters():
if param.requires_grad and name in self.fisher:
loss += (self.fisher[name] * (param - self.optimal_params[name]) ** 2).sum()
return lambda_ * loss / 2
class DistributionShiftDetector:
"""
Detects distribution shift using multiple statistical tests.
Implements MMD test, classifier-based detection, and group-stratified monitoring.
"""
def __init__(
self,
window_size: int = 100,
threshold: float = 0.05,
sensitive_attributes: Optional[List[str]] = None
):
"""
Initialize shift detector.
Args:
window_size: Number of recent samples to use for shift detection
threshold: P-value threshold for detecting significant shift
sensitive_attributes: Attributes to stratify shift detection
"""
self.window_size = window_size
self.threshold = threshold
self.sensitive_attributes = sensitive_attributes or []
# Maintain reference window from training data
self.reference_features: Optional[np.ndarray] = None
self.reference_metadata: Optional[Dict[str, np.ndarray]] = None
# Maintain recent deployment window
self.recent_features: deque = deque(maxlen=window_size)
self.recent_metadata: Dict[str, deque] = defaultdict(lambda: deque(maxlen=window_size))
def set_reference(
self,
features: np.ndarray,
metadata: Dict[str, np.ndarray]
) -> None:
"""
Set reference distribution from training data.
Args:
features: Reference feature array
metadata: Reference metadata dictionary
"""
self.reference_features = features
self.reference_metadata = metadata
logger.info(f"Set reference distribution with {len(features)} samples")
def update(
self,
features: np.ndarray,
metadata: Dict[str, np.ndarray]
) -> None:
"""
Update recent distribution window with new samples.
Args:
features: New feature array
metadata: New metadata dictionary
"""
for sample_features in features:
self.recent_features.append(sample_features)
for key, values in metadata.items():
for value in values:
self.recent_metadata[key].append(value)
def detect_shift(
self,
method: str = 'mmd'
) -> Dict[str, Any]:
"""
Detect distribution shift between reference and recent data.
Args:
method: Detection method ('mmd', 'classifier', or 'both')
Returns:
Dictionary with shift detection results including:
- shift_detected: Boolean indicating if shift detected
- p_value: P-value from statistical test
- group_results: Group-stratified results if applicable
"""
if self.reference_features is None:
raise ValueError("Reference distribution not set")
if len(self.recent_features) < self.window_size // 2:
logger.warning("Insufficient recent samples for reliable shift detection")
return {
'shift_detected': False,
'p_value': 1.0,
'message': 'Insufficient data'
}
recent_features = np.array(list(self.recent_features))
results = {
'shift_detected': False,
'p_value': 1.0,
'group_results': {}
}
if method in ['mmd', 'both']:
# Overall MMD test
p_value = self._mmd_test(self.reference_features, recent_features)
results['p_value'] = p_value
results['shift_detected'] = p_value < self.threshold
# Stratified tests by sensitive attributes
if self.sensitive_attributes and self.reference_metadata:
for attr in self.sensitive_attributes:
group_results = self._stratified_shift_test(attr)
results['group_results'][attr] = group_results
# Overall shift detected if any group shows shift
if any(r['shift_detected'] for r in group_results.values()):
results['shift_detected'] = True
return results
def _mmd_test(
self,
X: np.ndarray,
Y: np.ndarray,
kernel: str = 'rbf',
gamma: Optional[float] = None,
n_permutations: int = 100
) -> float:
"""
Compute MMD test for distribution shift.
Args:
X: Reference samples
Y: Recent samples
kernel: Kernel function ('rbf' or 'linear')
gamma: RBF kernel bandwidth (auto-computed if None)
n_permutations: Number of permutations for p-value estimation
Returns:
P-value for the null hypothesis that X and Y are from same distribution
"""
n = X.shape[0]
m = Y.shape[0]
if kernel == 'rbf':
if gamma is None:
# Median heuristic for bandwidth
dists = np.linalg.norm(X[:100] - X[:100, np.newaxis], axis=2)
gamma = 1.0 / (2 * np.median(dists[dists > 0]) ** 2)
def kernel_fn(x1, x2):
return np.exp(-gamma * np.linalg.norm(x1 - x2) ** 2)
else:
def kernel_fn(x1, x2):
return np.dot(x1, x2)
# Compute MMD statistic
def compute_mmd():
XX = sum(kernel_fn(X[i], X[j]) for i in range(n) for j in range(i+1, n))
YY = sum(kernel_fn(Y[i], Y[j]) for i in range(m) for j in range(i+1, m))
XY = sum(kernel_fn(X[i], Y[j]) for i in range(n) for j in range(m))
mmd = (2.0 * XX / (n * (n-1)) +
2.0 * YY / (m * (m-1)) -
2.0 * XY / (n * m))
return mmd
observed_mmd = compute_mmd()
# Permutation test
combined = np.vstack([X, Y])
permutation_mmds = []
for _ in range(n_permutations):
indices = np.random.permutation(n + m)
X_perm = combined[indices[:n]]
Y_perm = combined[indices[n:]]
# Recompute with permuted data
XX = sum(kernel_fn(X_perm[i], X_perm[j]) for i in range(n) for j in range(i+1, n))
YY = sum(kernel_fn(Y_perm[i], Y_perm[j]) for i in range(m) for j in range(i+1, m))
XY = sum(kernel_fn(X_perm[i], Y_perm[j]) for i in range(n) for j in range(m))
perm_mmd = (2.0 * XX / (n * (n-1)) +
2.0 * YY / (m * (m-1)) -
2.0 * XY / (n * m))
permutation_mmds.append(perm_mmd)
# Compute p-value
p_value = np.mean(np.array(permutation_mmds) >= observed_mmd)
return p_value
def _stratified_shift_test(self, attribute: str) -> Dict[Any, Dict[str, Any]]:
"""
Perform shift tests stratified by demographic groups.
Args:
attribute: Sensitive attribute to stratify by
Returns:
Dictionary mapping group values to shift test results
"""
if attribute not in self.reference_metadata:
return {}
group_results = {}
# Get unique group values
ref_groups = set(self.reference_metadata[attribute])
recent_groups = set(self.recent_metadata[attribute])
all_groups = ref_groups.union(recent_groups)
for group in all_groups:
# Extract samples for this group
ref_mask = self.reference_metadata[attribute] == group
if not any(ref_mask):
continue
recent_mask = np.array(list(self.recent_metadata[attribute])) == group
if not any(recent_mask):
group_results[group] = {
'shift_detected': True,
'p_value': 0.0,
'message': 'Group disappeared from recent data'
}
continue
ref_group_features = self.reference_features[ref_mask]
recent_group_features = np.array(list(self.recent_features))[recent_mask]
if len(recent_group_features) < 10:
group_results[group] = {
'shift_detected': False,
'p_value': 1.0,
'message': 'Insufficient recent samples'
}
continue
# Perform MMD test for this group
p_value = self._mmd_test(ref_group_features, recent_group_features)
group_results[group] = {
'shift_detected': p_value < self.threshold,
'p_value': p_value,
'n_reference': len(ref_group_features),
'n_recent': len(recent_group_features)
}
return group_results
class FairnessMonitor:
"""
Monitors fairness metrics across demographic groups during continual learning.
Tracks multiple fairness metrics and detects fairness degradation that should
trigger adaptation or rollback.
"""
def __init__(
self,
sensitive_attributes: List[str],
fairness_thresholds: Dict[str, float]
):
"""
Initialize fairness monitor.
Args:
sensitive_attributes: List of attributes to monitor
fairness_thresholds: Maximum acceptable disparities for each metric
"""
self.sensitive_attributes = sensitive_attributes
self.fairness_thresholds = fairness_thresholds
# Track fairness metrics over time
self.metric_history: Dict[str, List[float]] = defaultdict(list)
self.group_metric_history: Dict[Tuple[str, Any], List[Dict[str, float]]] = defaultdict(list)
def evaluate_fairness(
self,
y_true: np.ndarray,
y_pred: np.ndarray,
y_prob: np.ndarray,
metadata: Dict[str, np.ndarray]
) -> Dict[str, Any]:
"""
Evaluate fairness metrics across demographic groups.
Args:
y_true: True labels
y_pred: Predicted labels
y_prob: Predicted probabilities
metadata: Dictionary of metadata including sensitive attributes
Returns:
Dictionary with fairness metrics and violation flags
"""
results = {
'overall_metrics': self._compute_overall_metrics(y_true, y_pred, y_prob),
'group_metrics': {},
'disparities': {},
'violations': []
}
for attr in self.sensitive_attributes:
if attr not in metadata:
logger.warning(f"Sensitive attribute '{attr}' not found in metadata")
continue
attr_values = metadata[attr]
unique_values = np.unique(attr_values)
# Compute metrics for each group
group_metrics = {}
for value in unique_values:
mask = attr_values == value
if np.sum(mask) < 10: # Skip very small groups
continue
metrics = self._compute_overall_metrics(
y_true[mask],
y_pred[mask],
y_prob[mask]
)
group_metrics[value] = metrics
# Store in history
self.group_metric_history[(attr, value)].append(metrics)
results['group_metrics'][attr] = group_metrics
# Compute disparities
disparities = self._compute_disparities(group_metrics)
results['disparities'][attr] = disparities
# Check for violations
violations = self._check_violations(attr, disparities)
results['violations'].extend(violations)
# Store overall metrics in history
for metric, value in results['overall_metrics'].items():
self.metric_history[metric].append(value)
return results
def _compute_overall_metrics(
self,
y_true: np.ndarray,
y_pred: np.ndarray,
y_prob: np.ndarray
) -> Dict[str, float]:
"""Compute classification metrics."""
try:
metrics = {
'accuracy': accuracy_score(y_true, y_pred),
'auc': roc_auc_score(y_true, y_prob) if len(np.unique(y_true)) > 1 else 0.5
}
# Compute confusion matrix metrics
tn, fp, fn, tp = confusion_matrix(y_true, y_pred, labels=[0, 1]).ravel()
metrics['tpr'] = tp / (tp + fn) if (tp + fn) > 0 else 0.0 # True positive rate
metrics['fpr'] = fp / (fp + tn) if (fp + tn) > 0 else 0.0 # False positive rate
metrics['tnr'] = tn / (tn + fp) if (tn + fp) > 0 else 0.0 # True negative rate
metrics['fnr'] = fn / (fn + tp) if (fn + tp) > 0 else 0.0 # False negative rate
metrics['ppv'] = tp / (tp + fp) if (tp + fp) > 0 else 0.0 # Positive predictive value
return metrics
except Exception as e:
logger.error(f"Error computing metrics: {e}")
return {}
def _compute_disparities(
self,
group_metrics: Dict[Any, Dict[str, float]]
) -> Dict[str, float]:
"""
Compute disparity metrics across groups.
Args:
group_metrics: Metrics for each group
Returns:
Dictionary of disparity measures
"""
if len(group_metrics) < 2:
return {}
disparities = {}
# Get all metric names
metric_names = set()
for metrics in group_metrics.values():
metric_names.update(metrics.keys())
for metric in metric_names:
values = [m[metric] for m in group_metrics.values() if metric in m]
if len(values) >= 2:
disparities[f'{metric}_range'] = max(values) - min(values)
disparities[f'{metric}_ratio'] = max(values) / min(values) if min(values) > 0 else float('inf')
# Demographic parity difference (difference in positive prediction rates)
pos_rates = []
for metrics in group_metrics.values():
if 'tpr' in metrics and 'fpr' in metrics:
# Positive rate = P(Y_pred = 1) ≈ TPR * P(Y=1) + FPR * P(Y=0)
# For balanced classes, approximate as (TPR + FPR) / 2
pos_rate = (metrics['tpr'] + metrics['fpr']) / 2
pos_rates.append(pos_rate)
if len(pos_rates) >= 2:
disparities['demographic_parity_difference'] = max(pos_rates) - min(pos_rates)
# Equalized odds difference (max difference in TPR and FPR)
tprs = [m['tpr'] for m in group_metrics.values() if 'tpr' in m]
fprs = [m['fpr'] for m in group_metrics.values() if 'fpr' in m]
if len(tprs) >= 2 and len(fprs) >= 2:
tpr_diff = max(tprs) - min(tprs)
fpr_diff = max(fprs) - min(fprs)
disparities['equalized_odds_difference'] = max(tpr_diff, fpr_diff)
return disparities
def _check_violations(
self,
attribute: str,
disparities: Dict[str, float]
) -> List[Dict[str, Any]]:
"""
Check if disparities exceed acceptable thresholds.
Args:
attribute: Sensitive attribute being checked
disparities: Computed disparity measures
Returns:
List of violation dictionaries
"""
violations = []
for metric, threshold in self.fairness_thresholds.items():
if metric in disparities and disparities[metric] > threshold:
violations.append({
'attribute': attribute,
'metric': metric,
'value': disparities[metric],
'threshold': threshold,
'message': f"{metric} disparity {disparities[metric]:.3f} exceeds threshold {threshold:.3f}"
})
return violations
def get_fairness_trend(
self,
metric: str,
window: int = 10
) -> Dict[str, Any]:
"""
Analyze trend in fairness metric over time.
Args:
metric: Metric name to analyze
window: Window size for trend analysis
Returns:
Dictionary with trend analysis results
"""
if metric not in self.metric_history:
return {'trend': 'unknown', 'message': 'Insufficient history'}
history = self.metric_history[metric][-window:]
if len(history) < 3:
return {'trend': 'insufficient_data', 'values': history}
# Simple linear regression for trend
x = np.arange(len(history))
slope = np.polyfit(x, history, 1)[0]
return {
'trend': 'improving' if slope < -0.001 else 'degrading' if slope > 0.001 else 'stable',
'slope': slope,
'recent_values': history,
'mean': np.mean(history),
'std': np.std(history)
}
class ContinualLearningSystem:
"""
Complete continual learning system with fairness monitoring.
Integrates EWC, experience replay, shift detection, and fairness-aware adaptation
for healthcare applications.
"""
def __init__(
self,
model: nn.Module,
config: ContinualLearningConfig
):
"""
Initialize continual learning system.
Args:
model: Neural network model to adapt
config: Configuration for continual learning
"""
self.model = model
self.config = config
# Initialize components
self.memory = MemoryBuffer(
max_size=config.memory_size,
selection_strategy=config.memory_selection_strategy,
sensitive_attributes=config.sensitive_attributes
)
self.fisher = FisherInformationMatrix(model)
self.shift_detector = DistributionShiftDetector(
window_size=config.shift_detection_window,
threshold=config.shift_detection_threshold,
sensitive_attributes=config.sensitive_attributes
)
self.fairness_monitor = FairnessMonitor(
sensitive_attributes=config.sensitive_attributes,
fairness_thresholds=config.fairness_threshold
)
# Track adaptation history
self.adaptation_history: List[Dict[str, Any]] = []
self.current_task = 0
def initial_training(
self,
train_loader: DataLoader,
val_loader: DataLoader,
epochs: int = 10,
lr: float = 0.001
) -> Dict[str, Any]:
"""
Perform initial training on first task.
Args:
train_loader: Training data loader
val_loader: Validation data loader
epochs: Number of training epochs
lr: Learning rate
Returns:
Dictionary with training results
"""
logger.info("Starting initial training...")
optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
criterion = nn.BCEWithLogitsLoss()
self.model.train()
for epoch in range(epochs):
epoch_loss = 0.0
n_batches = 0
for features, labels, metadata in train_loader:
features = features.float()
labels = labels.float()
optimizer.zero_grad()
outputs = self.model(features).squeeze()
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
epoch_loss += loss.item()
n_batches += 1
avg_loss = epoch_loss / n_batches
logger.info(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}")
# Evaluate on validation set
val_results = self._evaluate(val_loader)
# Compute Fisher information
self.fisher.compute_fisher(
train_loader,
num_samples=self.config.fisher_estimation_samples
)
# Populate memory buffer
for features, labels, metadata in train_loader:
self.memory.add_batch(
features.numpy(),
labels.numpy(),
metadata
)
# Set reference distribution for shift detection
all_features = []
all_metadata = defaultdict(list)
for features, labels, metadata in train_loader:
all_features.append(features.numpy())
for key, val in metadata.items():
all_metadata[key].extend(val)
all_features = np.vstack(all_features)
all_metadata = {k: np.array(v) for k, v in all_metadata.items()}
self.shift_detector.set_reference(all_features, all_metadata)
logger.info("Initial training completed")
return {
'task': 0,
'validation_results': val_results,
'memory_size': len(self.memory.data),
'timestamp': datetime.now().isoformat()
}
def continual_update(
self,
new_data_loader: DataLoader,
val_loader: DataLoader
) -> Dict[str, Any]:
"""
Perform continual learning update with new data.
Args:
new_data_loader: DataLoader with new data
val_loader: Validation data loader
Returns:
Dictionary with update results and fairness metrics
"""
self.current_task += 1
logger.info(f"Starting continual update for task {self.current_task}")
# Detect distribution shift
new_features = []
new_metadata = defaultdict(list)
for features, labels, metadata in new_data_loader:
new_features.append(features.numpy())
for key, val in metadata.items():
new_metadata[key].extend(val)
new_features = np.vstack(new_features)
new_metadata = {k: np.array(v) for k, v in new_metadata.items()}
self.shift_detector.update(new_features, new_metadata)
shift_results = self.shift_detector.detect_shift()
logger.info(f"Shift detection: {shift_results['shift_detected']}, p-value: {shift_results['p_value']:.4f}")
# Evaluate baseline performance before update
baseline_results = self._evaluate(val_loader)
# Perform adaptation based on strategy
if self.config.adaptation_strategy == 'ewc_replay':
adaptation_results = self._ewc_replay_adaptation(
new_data_loader,
val_loader
)
elif self.config.adaptation_strategy == 'fine_tune':
adaptation_results = self._fine_tune_adaptation(
new_data_loader,
val_loader
)
elif self.config.adaptation_strategy == 'full_retrain':
adaptation_results = self._full_retrain_adaptation(
new_data_loader,
val_loader
)
else:
raise ValueError(f"Unknown adaptation strategy: {self.config.adaptation_strategy}")
# Evaluate post-adaptation performance
post_results = self._evaluate(val_loader)
# Check for fairness violations or performance degradation
violations = post_results['fairness']['violations']
decision = 'accept'
if violations:
logger.warning(f"Fairness violations detected: {len(violations)}")
decision = 'reject'
# Check for severe performance degradation in any group
for attr in self.config.sensitive_attributes:
if attr in baseline_results['fairness']['group_metrics'] and \
attr in post_results['fairness']['group_metrics']:
baseline_groups = baseline_results['fairness']['group_metrics'][attr]
post_groups = post_results['fairness']['group_metrics'][attr]
for group in baseline_groups:
if group in post_groups:
baseline_acc = baseline_groups[group].get('accuracy', 0)
post_acc = post_groups[group].get('accuracy', 0)
if post_acc < baseline_acc - 0.05: # 5% degradation threshold
logger.warning(
f"Severe accuracy degradation for {attr}={group}: "
f"{baseline_acc:.3f} -> {post_acc:.3f}"
)
decision = 'reject'
# Update memory and Fisher if adaptation accepted
if decision == 'accept':
# Add new data to memory
for features, labels, metadata in new_data_loader:
self.memory.add_batch(
features.numpy(),
labels.numpy(),
metadata
)
# Recompute Fisher information
self.fisher.compute_fisher(
new_data_loader,
num_samples=self.config.fisher_estimation_samples
)
else:
logger.warning("Adaptation rejected due to fairness violations or degradation")
# In a real system, would roll back model weights here
# Record adaptation in history
adaptation_record = {
'task': self.current_task,
'timestamp': datetime.now().isoformat(),
'shift_detected': shift_results['shift_detected'],
'shift_details': shift_results,
'baseline_performance': baseline_results,
'post_performance': post_results,
'adaptation_details': adaptation_results,
'decision': decision,
'violations': violations
}
self.adaptation_history.append(adaptation_record)
return adaptation_record
def _ewc_replay_adaptation(
self,
new_data_loader: DataLoader,
val_loader: DataLoader
) -> Dict[str, Any]:
"""
Adapt using EWC regularization and experience replay.
Args:
new_data_loader: DataLoader with new data
val_loader: Validation data loader
Returns:
Dictionary with adaptation results
"""
logger.info("Performing EWC + replay adaptation")
optimizer = torch.optim.Adam(
self.model.parameters(),
lr=self.config.adaptation_lr
)
criterion = nn.BCEWithLogitsLoss()
self.model.train()
epoch_losses = []
for epoch in range(self.config.adaptation_epochs):
epoch_loss = 0.0
ewc_loss_total = 0.0
replay_loss_total = 0.0
n_batches = 0
for features, labels, metadata in new_data_loader:
features = features.float()
labels = labels.float()
# Get replay batch
batch_size = features.shape[0]
replay_size = int(batch_size * self.config.replay_batch_fraction)
if replay_size > 0 and len(self.memory.data) > 0:
replay_features, replay_labels, _ = self.memory.sample(replay_size)
replay_features = torch.tensor(replay_features, dtype=torch.float32)
replay_labels = torch.tensor(replay_labels, dtype=torch.float32)
# Combine new and replay data
combined_features = torch.cat([features, replay_features])
combined_labels = torch.cat([labels, replay_labels])
else:
combined_features = features
combined_labels = labels
replay_size = 0
optimizer.zero_grad()
# Forward pass
outputs = self.model(combined_features).squeeze()
# Compute task loss
task_loss = criterion(outputs, combined_labels)
# Compute EWC loss
ewc_loss = self.fisher.ewc_loss(self.config.ewc_lambda)
# Total loss
loss = task_loss + ewc_loss
loss.backward()
optimizer.step()
epoch_loss += loss.item()
ewc_loss_total += ewc_loss.item()
if replay_size > 0:
replay_loss_total += criterion(
outputs[-replay_size:],
combined_labels[-replay_size:]
).item()
n_batches += 1
avg_loss = epoch_loss / n_batches
avg_ewc_loss = ewc_loss_total / n_batches
avg_replay_loss = replay_loss_total / n_batches if replay_loss_total > 0 else 0
epoch_losses.append(avg_loss)
logger.info(
f"Epoch {epoch+1}/{self.config.adaptation_epochs}, "
f"Loss: {avg_loss:.4f}, EWC: {avg_ewc_loss:.4f}, Replay: {avg_replay_loss:.4f}"
)
return {
'strategy': 'ewc_replay',
'epochs': self.config.adaptation_epochs,
'final_loss': epoch_losses[-1],
'loss_history': epoch_losses
}
def _fine_tune_adaptation(
self,
new_data_loader: DataLoader,
val_loader: DataLoader
) -> Dict[str, Any]:
"""
Adapt using simple fine-tuning with low learning rate.
Args:
new_data_loader: DataLoader with new data
val_loader: Validation data loader
Returns:
Dictionary with adaptation results
"""
logger.info("Performing fine-tuning adaptation")
optimizer = torch.optim.Adam(
self.model.parameters(),
lr=self.config.adaptation_lr * 0.1 # Even lower LR for fine-tuning
)
criterion = nn.BCEWithLogitsLoss()
self.model.train()
epoch_losses = []
for epoch in range(self.config.adaptation_epochs):
epoch_loss = 0.0
n_batches = 0
for features, labels, metadata in new_data_loader:
features = features.float()
labels = labels.float()
optimizer.zero_grad()
outputs = self.model(features).squeeze()
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
epoch_loss += loss.item()
n_batches += 1
avg_loss = epoch_loss / n_batches
epoch_losses.append(avg_loss)
logger.info(f"Epoch {epoch+1}/{self.config.adaptation_epochs}, Loss: {avg_loss:.4f}")
return {
'strategy': 'fine_tune',
'epochs': self.config.adaptation_epochs,
'final_loss': epoch_losses[-1],
'loss_history': epoch_losses
}
def _full_retrain_adaptation(
self,
new_data_loader: DataLoader,
val_loader: DataLoader
) -> Dict[str, Any]:
"""
Adapt by retraining from scratch on combined old + new data.
Args:
new_data_loader: DataLoader with new data
val_loader: Validation data loader
Returns:
Dictionary with adaptation results
"""
logger.info("Performing full retraining")
# Combine memory and new data
# In practice, would need to construct proper combined dataset
# For now, just train on new data (simplified)
# Reset model parameters
for layer in self.model.children():
if hasattr(layer, 'reset_parameters'):
layer.reset_parameters()
return self._fine_tune_adaptation(new_data_loader, val_loader)
def _evaluate(self, data_loader: DataLoader) -> Dict[str, Any]:
"""
Evaluate model performance including fairness metrics.
Args:
data_loader: DataLoader for evaluation
Returns:
Dictionary with performance and fairness metrics
"""
self.model.eval()
all_features = []
all_labels = []
all_predictions = []
all_probabilities = []
all_metadata = defaultdict(list)
with torch.no_grad():
for features, labels, metadata in data_loader:
features = features.float()
outputs = self.model(features).squeeze()
probabilities = torch.sigmoid(outputs)
predictions = (probabilities > 0.5).float()
all_features.append(features.numpy())
all_labels.append(labels.numpy())
all_predictions.append(predictions.numpy())
all_probabilities.append(probabilities.numpy())
for key, val in metadata.items():
all_metadata[key].extend(val)
# Concatenate all batches
all_labels = np.concatenate(all_labels)
all_predictions = np.concatenate(all_predictions)
all_probabilities = np.concatenate(all_probabilities)
all_metadata = {k: np.array(v) for k, v in all_metadata.items()}
# Compute fairness metrics
fairness_results = self.fairness_monitor.evaluate_fairness(
all_labels,
all_predictions,
all_probabilities,
all_metadata
)
return {
'overall': fairness_results['overall_metrics'],
'fairness': fairness_results
}
def save_state(self, filepath: str) -> None:
"""Save complete system state."""
state = {
'model_state': self.model.state_dict(),
'fisher_information': self.fisher.fisher,
'fisher_optimal_params': self.fisher.optimal_params,
'memory_data': self.memory.data,
'adaptation_history': self.adaptation_history,
'current_task': self.current_task,
'config': {
'memory_size': self.config.memory_size,
'ewc_lambda': self.config.ewc_lambda,
'sensitive_attributes': self.config.sensitive_attributes
}
}
torch.save(state, filepath)
logger.info(f"Saved system state to {filepath}")
def load_state(self, filepath: str) -> None:
"""Load complete system state."""
state = torch.load(filepath)
self.model.load_state_dict(state['model_state'])
self.fisher.fisher = state['fisher_information']
self.fisher.optimal_params = state['fisher_optimal_params']
self.memory.data = state['memory_data']
self.adaptation_history = state['adaptation_history']
self.current_task = state['current_task']
logger.info(f"Loaded system state from {filepath}")
# Example usage
if __name__ == "__main__":
# Set random seeds for reproducibility
np.random.seed(42)
torch.manual_seed(42)
# Create synthetic healthcare dataset with demographic attributes
n_samples = 1000
n_features = 20
X = np.random.randn(n_samples, n_features).astype(np.float32)
y = (X[:, 0] + X[:, 1] + 0.5 * np.random.randn(n_samples) > 0).astype(np.float32)
# Create demographic metadata
race = np.random.choice(['White', 'Black', 'Hispanic', 'Asian'], size=n_samples)
sex = np.random.choice(['Male', 'Female'], size=n_samples)
age_group = np.random.choice(['<45', '45-65', '>65'], size=n_samples)
metadata = {
'race': race,
'sex': sex,
'age_group': age_group
}
# Create data loaders
train_dataset = TensorDataset(
torch.tensor(X[:700]),
torch.tensor(y[:700])
)
val_dataset = TensorDataset(
torch.tensor(X[700:]),
torch.tensor(y[700:])
)
# Custom collate function to include metadata
def collate_with_metadata(batch):
features = torch.stack([item[0] for item in batch])
labels = torch.stack([item[1] for item in batch])
indices = [i for i, _ in enumerate(batch)]
batch_metadata = {
'race': race[indices],
'sex': sex[indices],
'age_group': age_group[indices]
}
return features, labels, batch_metadata
train_loader = DataLoader(
train_dataset,
batch_size=32,
shuffle=True,
collate_fn=collate_with_metadata
)
val_loader = DataLoader(
val_dataset,
batch_size=32,
collate_fn=collate_with_metadata
)
# Define simple neural network
class SimpleClassifier(nn.Module):
def __init__(self, input_dim, hidden_dim=64):
super().__init__()
self.fc1 = nn.Linear(input_dim, hidden_dim)
self.fc2 = nn.Linear(hidden_dim, hidden_dim)
self.fc3 = nn.Linear(hidden_dim, 1)
def forward(self, x):
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x
model = SimpleClassifier(n_features)
# Initialize continual learning system
config = ContinualLearningConfig(
memory_size=200,
ewc_lambda=5000.0,
sensitive_attributes=['race', 'sex', 'age_group']
)
cl_system = ContinualLearningSystem(model, config)
# Initial training
print("\n" + "="*60)
print("INITIAL TRAINING")
print("="*60)
initial_results = cl_system.initial_training(train_loader, val_loader, epochs=5)
print(f"\nInitial validation accuracy: {initial_results['validation_results']['overall']['accuracy']:.4f}")
print(f"Initial validation AUC: {initial_results['validation_results']['overall']['auc']:.4f}")
# Simulate new data with distribution shift
X_new = np.random.randn(500, n_features).astype(np.float32) + 0.5 # Shift mean
y_new = (X_new[:, 0] + X_new[:, 1] + 0.5 * np.random.randn(500) > 0).astype(np.float32)
race_new = np.random.choice(['White', 'Black', 'Hispanic', 'Asian'], size=500)
sex_new = np.random.choice(['Male', 'Female'], size=500)
age_group_new = np.random.choice(['<45', '45-65', '>65'], size=500)
new_dataset = TensorDataset(
torch.tensor(X_new[:400]),
torch.tensor(y_new[:400])
)
def collate_new_metadata(batch):
features = torch.stack([item[0] for item in batch])
labels = torch.stack([item[1] for item in batch])
indices = [i for i, _ in enumerate(batch)]
batch_metadata = {
'race': race_new[indices],
'sex': sex_new[indices],
'age_group': age_group_new[indices]
}
return features, labels, batch_metadata
new_loader = DataLoader(
new_dataset,
batch_size=32,
shuffle=True,
collate_fn=collate_new_metadata
)
# Continual update
print("\n" + "="*60)
print("CONTINUAL UPDATE WITH NEW DATA")
print("="*60)
update_results = cl_system.continual_update(new_loader, val_loader)
print(f"\nShift detected: {update_results['shift_detected']}")
print(f"Adaptation decision: {update_results['decision']}")
print(f"Post-update accuracy: {update_results['post_performance']['overall']['accuracy']:.4f}")
print(f"Post-update AUC: {update_results['post_performance']['overall']['auc']:.4f}")
if update_results['violations']:
print(f"\nFairness violations: {len(update_results['violations'])}")
for violation in update_results['violations'][:3]:
print(f" - {violation['message']}")
# Display group-specific performance
print("\n" + "="*60)
print("GROUP-SPECIFIC PERFORMANCE")
print("="*60)
for attr in config.sensitive_attributes:
print(f"\n{attr.upper()}:")
if attr in update_results['post_performance']['fairness']['group_metrics']:
group_metrics = update_results['post_performance']['fairness']['group_metrics'][attr]
for group, metrics in group_metrics.items():
print(f" {group}: Acc={metrics['accuracy']:.3f}, AUC={metrics['auc']:.3f}")
# Save system state
cl_system.save_state('/mnt/user-data/outputs/continual_learning_checkpoint.pt')
print("\nSystem state saved")
This implementation provides a production-ready continual learning system with comprehensive fairness monitoring throughout the adaptation process. The system integrates multiple continual learning techniques including Elastic Weight Consolidation for preserving important parameters, stratified experience replay for maintaining diverse population representation, and multi-objective fairness monitoring that ensures model updates do not degrade performance for specific demographic groups.
The memory buffer implements fairness-aware sampling strategies that explicitly allocate capacity across demographic strata, preventing minority groups from being underrepresented in replay. The Fisher information computation identifies parameters crucial for maintaining performance on historical tasks, with potential for stratified computation across groups to ensure parameters important for minority populations are adequately protected.
Distribution shift detection operates at both aggregate and group-stratified levels, ensuring that shifts primarily affecting minority populations are not masked by majority population stability. The fairness monitor tracks multiple metrics including demographic parity, equalized odds, and group-specific accuracy, with explicit thresholds for acceptable disparities that trigger adaptation rejection or rollback.
The adaptation strategies balance stability with plasticity: EWC regularization prevents catastrophic forgetting of historical patterns while allowing the model to learn new patterns from recent data, replay ensures continued exposure to diverse historical examples during adaptation, and fairness-constrained evaluation ensures updates are accepted only when they maintain or improve fairness across all demographic groups.
Governance and Versioning for Model Evolution
Deploying continual learning systems in healthcare requires robust governance frameworks that ensure transparency, accountability, and trust as models evolve. Unlike static models that undergo a single validation before deployment and then remain frozen, continual learning systems change over time, potentially altering their behavior in ways that affect clinical decision-making and patient outcomes. This dynamic nature necessitates governance processes that track model evolution, communicate changes to stakeholders, and maintain regulatory compliance throughout the model lifecycle.
Model Versioning Strategies
Effective versioning enables tracking model changes, rolling back problematic updates, and maintaining reproducibility for audit and research purposes. Several versioning strategies exist:
Sequential Versioning: Assign incrementing version numbers to each model update. Major version increments indicate substantial changes such as architectural modifications or retraining on significantly new data distributions, while minor version increments indicate smaller updates like fine-tuning on recent data. For example, version 2.0 might indicate a major model architecture change, version 2.1 a quarterly retraining cycle, and version 2.1.1 a hotfix for a specific edge case.
Timestamp-Based Versioning: Use timestamps to identify model versions, providing clear temporal ordering and facilitating analysis of performance trends over time. This approach naturally integrates with continuous deployment pipelines where models may be updated on regular schedules (e.g., monthly retraining) or triggered by detected distribution shift.
Content-Based Versioning: Use cryptographic hashes of model weights and metadata to create unique version identifiers. This ensures any change to model parameters, hyperparameters, or training data provenance results in a new version, enabling precise tracking of model evolution and preventing accidental deployment of wrong versions.
Semantic Versioning: Adapt software engineering semantic versioning (MAJOR.MINOR.PATCH) to machine learning contexts. MAJOR version changes indicate backward-incompatible changes such as different input features or output formats, MINOR versions indicate new capabilities or performance improvements with backward compatibility, and PATCH versions indicate bug fixes or minor refinements that don’t alter behavior for typical inputs.
For healthcare applications, versioning should capture not only the model itself but also the complete training and evaluation context including training data provenance and composition (which datasets, what time periods, demographic distributions), preprocessing pipelines and feature engineering steps, hyperparameters and training procedures, evaluation metrics stratified by demographic groups, and validation protocols and clinical testing results. This comprehensive versioning enables reproducing model behavior for regulatory review or post-market surveillance.
Testing and Validation Before Deployment
Before deploying updated models, rigorous testing ensures they maintain or improve performance across all relevant dimensions:
Shadow Deployment: Run the updated model in parallel with the existing production model without affecting clinical decisions. Compare predictions between models to identify cases where they disagree, enabling investigation of whether the updated model provides better or worse recommendations. Shadow deployment allows accumulating evidence about updated model behavior in real deployment conditions before committing to using its predictions.
A/B Testing: Randomly assign patients or clinical encounters to receive predictions from either the current production model or the updated model. Monitor clinical outcomes and operational metrics across both groups to assess whether the updated model improves care. For healthcare, A/B testing requires careful ethical consideration and institutional review board approval, as it involves potentially providing different quality care to randomly selected patients.
Canary Deployment: Gradually roll out the updated model to increasing fractions of the deployment population, starting with a small percentage and expanding if no adverse effects are observed. Canary deployment provides a middle ground between shadow deployment (which never affects decisions) and full deployment (which immediately affects all decisions), allowing early detection of problems that can be addressed before widespread impact.
Stratified Validation: Before any deployment, evaluate the updated model on held-out validation data stratified by demographic groups, clinical settings, and other relevant dimensions. Establish go/no-go criteria: the updated model must maintain or improve performance on each demographic group, must not increase fairness metric disparities beyond acceptable thresholds, and must not degrade performance on rare but important cases or diagnoses. Only if these criteria are met should deployment proceed.
Regression Testing: Maintain a test suite of challenging or important cases that previous model versions handled correctly. Ensure updated models continue handling these cases appropriately. This prevents regression where adaptation to new patterns causes the model to fail on previously mastered scenarios. For underserved populations, regression tests should particularly emphasize cases involving minority groups or rare presentations to ensure adaptation doesn’t cause the model to forget these important scenarios.
Stakeholder Communication
Transparent communication about model updates builds trust and enables clinical users to appropriately calibrate their reliance on model predictions:
Change Logs: Maintain detailed change logs documenting what changed in each model version, why the change was made, what validation was performed, and what impacts are expected. Change logs should be accessible to clinicians, administrators, and patients, written in plain language with technical details available for those who want deeper understanding.
Notification Systems: Proactively notify users when model updates occur. Notifications should explain what changed, provide evidence supporting the update, and highlight any changes in model behavior or interpretation. For major updates, consider requiring users to acknowledge the notification and review summary information before continuing to use the model.
Performance Dashboards: Provide ongoing visibility into model performance through dashboards that show accuracy, calibration, and fairness metrics over time, stratified by demographic groups and clinical contexts. Dashboards enable clinicians and administrators to monitor whether the model continues performing appropriately and to identify potential problems early.
Community Engagement: For models deployed in underserved communities, engage with community organizations, patient advocacy groups, and local healthcare providers to communicate about model updates and solicit feedback. Community engagement builds trust by demonstrating transparency and responsiveness to community concerns about algorithmic decision-making in healthcare.
Regulatory Considerations
In the United States, the FDA regulates certain clinical decision support software as medical devices under the 21st Century Cures Act. The distinction between clinical decision support that is not regulated versus software as a medical device that requires premarket review depends on whether the software drives clinical decisions or merely provides information for clinician consideration, and whether the software analyzes medical images or other patient-specific data.
For continual learning systems that constitute medical devices, several regulatory pathways exist:
Predetermined Change Control Plans: The FDA has issued guidance allowing manufacturers to specify in advance what types of model changes may occur and how they will be validated, without requiring new 510(k) submissions for each change. This approach is particularly relevant for continual learning systems where the manufacturer can specify that the model will be periodically retrained on new data using a predetermined procedure, with specified validation protocols and acceptance criteria. The initial 510(k) submission includes the predetermined change control plan, and subsequent changes following that plan do not require new submissions as long as they stay within the prespecified bounds.
Software as a Medical Device Pre-Cert Pilot: The FDA’s pre-certification pilot program focuses on evaluating organizations’ software development processes and quality systems rather than individual products. Organizations with robust software practices may receive expedited review or reduced regulatory burden for software updates. This approach could be particularly beneficial for continual learning systems where frequent updates are expected and organizational processes for validation and monitoring are more relevant than single-product assessments.
Real-World Performance Monitoring: Even after market clearance, medical device manufacturers must monitor real-world performance and report adverse events. For continual learning systems, this monitoring takes on additional importance as model behavior may change over time. Manufacturers should establish continuous monitoring systems that track performance metrics, detect anomalies, and trigger investigation when concerning patterns emerge.
For models deployed in settings or for purposes that do not constitute medical devices, regulatory requirements may be minimal, but ethical obligations remain. Even when not legally required, robust testing, transparent communication, and ongoing monitoring are essential for responsible deployment.
Documentation and Audit Trails
Comprehensive documentation enables accountability and supports post-market surveillance, regulatory audits, and research on model evolution:
Training Data Provenance: Document the sources, time periods, and compositions of training data for each model version. Track how data composition changes over time, particularly demographic distributions, to understand how training data evolution may affect model behavior across populations.
Decision Rationale: For each model update, document the rationale for updating, what problems the update aims to address, what alternative approaches were considered, and why the chosen approach was selected. This decision documentation enables retrospective analysis of whether update decisions were appropriate and what could be improved in future governance processes.
Validation Results: Maintain comprehensive records of validation results for each model version, including performance metrics stratified by demographic groups, fairness audits, comparison with previous versions, and any identified concerns or limitations. These records support regulatory review and enable researchers to analyze how model performance evolves over time.
Deployment History: Track when each model version was deployed, to what settings or populations, and for what duration. Deployment history enables linking clinical outcomes to specific model versions, supporting post-market surveillance and research on model effectiveness.
Incident Reports: Document any incidents where model predictions may have contributed to adverse outcomes, near-misses, or user concerns. Incident reports should trigger investigation of whether the model requires updates or whether other interventions (such as additional user training or modified clinical workflows) are needed.
Conclusion
Continual learning addresses the fundamental reality that healthcare is dynamic: patient populations evolve, clinical practices advance, and disease presentations change. Machine learning models deployed in healthcare must adapt to these changes while maintaining high performance and equitable care across all populations. This chapter has examined the technical foundations of continual learning, from catastrophic forgetting and its mitigation through regularization-based, replay-based, and architecture-based approaches, to distribution shift detection and adaptation strategies, to fairness-aware continual learning that ensures model evolution does not degrade care for underserved populations.
The implementations provided offer production-ready systems integrating multiple continual learning techniques with comprehensive fairness monitoring. The memory buffer implements stratified sampling to ensure adequate representation of all demographic groups in replay, the Fisher information matrix identifies parameters crucial for preserving important knowledge, distribution shift detection operates at both aggregate and group-stratified levels, and fairness monitoring tracks multiple metrics with explicit thresholds that trigger adaptation rejection when fairness degrades unacceptably.
Governance frameworks for model evolution are equally critical. Version control, rigorous testing before deployment, transparent stakeholder communication, and regulatory compliance ensure that continual learning systems remain accountable and trustworthy as they evolve. Documentation and audit trails enable retrospective analysis and support continuous improvement of governance processes.
For practitioners developing continual learning systems for healthcare, several key principles emerge. First, design with fairness from the start: fairness-aware continual learning requires explicit mechanisms throughout the system architecture, not post-hoc patches. Stratified memory buffers, group-specific shift detection, and fairness constraints during adaptation should be core components of any healthcare continual learning system. Second, balance stability with plasticity thoughtfully: the optimal tradeoff depends on domain specifics, with safety-critical applications generally favoring stability while applications in rapidly evolving domains may require more aggressive adaptation. Third, communicate transparently: stakeholders including clinicians, administrators, patients, and communities deserve clear explanations of how and why models change. Fourth, validate rigorously: comprehensive testing stratified by demographic groups and clinical contexts should precede any deployment, with clear go/no-go criteria established in advance. Finally, monitor continuously: ongoing performance tracking, fairness audits, and shift detection should operate throughout deployment, triggering investigation and potential intervention when concerning patterns emerge.
The path forward for continual learning in healthcare involves both technical and sociotechnical research. Technically, methods that better preserve minority group performance during adaptation, architectures that can grow capacity in fairness-aware ways, and algorithms that can adapt to multiple simultaneous distribution shifts remain important research directions. Sociotechnically, governance frameworks that appropriately balance innovation with safety, stakeholder engagement approaches that build trust in evolving algorithms, and regulatory pathways that enable beneficial adaptation while maintaining accountability all require continued development.
Ultimately, continual learning enables machine learning to be a long-term partner in healthcare rather than a static tool that inevitably becomes outdated. When implemented responsibly with explicit attention to fairness and governance, continual learning can help ensure that all patients benefit from advances in medical knowledge and artificial intelligence, regardless of their demographic characteristics, geographic location, or socioeconomic status.
Bibliography
Aljundi, R., Babiloni, F., Elhoseiny, M., Rohrbach, M., & Tuytelaars, T. (2018). Memory aware synapses: Learning what (not) to forget. Proceedings of the European Conference on Computer Vision (ECCV), 139-154.
Castro, F. M., Marín-Jiménez, M. J., Guil, N., Schmid, C., & Alahari, K. (2018). End-to-end incremental learning. Proceedings of the European Conference on Computer Vision (ECCV), 233-248.
Chen, I. Y., Pierson, E., Rose, S., Joshi, S., Ferryman, K., & Ghassemi, M. (2021). Ethical machine learning in healthcare. Annual Review of Biomedical Data Science, 4, 123-144.
Choi, E., Bahadori, M. T., Song, L., Stewart, W. F., & Sun, J. (2017). GRAM: Graph-based attention model for healthcare representation learning. Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, 787-795.
De Lange, M., Aljundi, R., Masana, M., Parisot, S., Jia, X., Leonardis, A., … & Tuytelaars, T. (2021). A continual learning survey: Defying forgetting in classification tasks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 44(7), 3366-3385.
Dhar, P., Singh, R. V., Peng, K. C., Wu, Z., & Chellappa, R. (2019). Learning without memorizing. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, 5138-5146.
French, R. M. (1999). Catastrophic forgetting in connectionist networks. Trends in Cognitive Sciences, 3(4), 128-135.
Gama, J., Žliobaitė, I., Bifet, A., Pechenizkiy, M., & Bouchachia, A. (2014). A survey on concept drift adaptation. ACM Computing Surveys, 46(4), 1-37.
Garg, S., Balakrishnan, S., Lipton, Z. C., Neyshabur, B., & Sedghi, H. (2020). Leveraging sparse linear layers for debuggable deep networks. Proceedings of the 37th International Conference on Machine Learning, 3429-3439.
Gretton, A., Borgwardt, K. M., Rasch, M. J., Schölkopf, B., & Smola, A. (2012). A kernel two-sample test. Journal of Machine Learning Research, 13(25), 723-773.
Hadsell, R., Rao, D., Rusu, A. A., & Pascanu, R. (2020). Embracing change: Continual learning in deep neural networks. Trends in Cognitive Sciences, 24(12), 1028-1040.
He, J., Spokoyny, D., Neubig, G., & Berg-Kirkpatrick, T. (2021). An empirical investigation of commonsense self-supervision with knowledge graphs. Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing, 8924-8935.
Hung, C. Y., Tu, C. H., Wu, C. E., Chen, C. H., Chan, Y. M., & Chen, C. S. (2019). Compacting, picking and growing for unforgetting continual learning. Advances in Neural Information Processing Systems, 32, 13669-13679.
Kirkpatrick, J., Pascanu, R., Rabinowitz, N., Veness, J., Desjardins, G., Rusu, A. A., … & Hadsell, R. (2017). Overcoming catastrophic forgetting in neural networks. Proceedings of the National Academy of Sciences, 114(13), 3521-3526.
Koh, P. W., Sagawa, S., Marklund, H., Xie, S. M., Zhang, M., Balsubramani, A., … & Liang, P. (2021). WILDS: A benchmark of in-the-wild distribution shifts. Proceedings of the 38th International Conference on Machine Learning, 5637-5664.
Li, Z., & Hoiem, D. (2017). Learning without forgetting. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(12), 2935-2947.
Lopez-Paz, D., & Ranzato, M. A. (2017). Gradient episodic memory for continual learning. Advances in Neural Information Processing Systems, 30, 6467-6476.
Mallya, A., & Lazebnik, S. (2018). PackNet: Adding multiple tasks to a single network by iterative pruning. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 7765-7773.
McCloskey, M., & Cohen, N. J. (1989). Catastrophic interference in connectionist networks: The sequential learning problem. Psychology of Learning and Motivation, 24, 109-165.
Moreno-Torres, J. G., Raeder, T., Alaiz-Rodríguez, R., Chawla, N. V., & Herrera, F. (2012). A unifying view on dataset shift in classification. Pattern Recognition, 45(1), 521-530.
Oberst, M., Johansson, F., Wei, D., Gao, T., Brat, G., Sontag, D., & Varshney, K. (2020). Characterization of overlap in observational studies. Proceedings of the 23rd International Conference on Artificial Intelligence and Statistics, 788-798.
Parisi, G. I., Kemker, R., Part, J. L., Kanan, C., & Wermter, S. (2019). Continual lifelong learning with neural networks: A review. Neural Networks, 113, 54-71.
Quiñonero-Candela, J., Sugiyama, M., Schwaighofer, A., & Lawrence, N. D. (2009). Dataset Shift in Machine Learning. MIT Press.
Rajkomar, A., Hardt, M., Howell, M. D., Corrado, G., & Chin, M. H. (2018). Ensuring fairness in machine learning to advance health equity. Annals of Internal Medicine, 169(12), 866-872.
Rebuffi, S. A., Kolesnikov, A., Sperl, G., & Lampert, C. H. (2017). iCaRL: Incremental classifier and representation learning. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2001-2010.
Rusu, A. A., Rabinowitz, N. C., Desjardins, G., Soyer, H., Kirkpatrick, J., Kavukcuoglu, K., … & Hadsell, R. (2016). Progressive neural networks. arXiv preprint arXiv:1606.04671.
Schwarz, J., Czarnecki, W., Luketina, J., Grabska-Barwinska, A., Teh, Y. W., Pascanu, R., & Hadsell, R. (2018). Progress & compress: A scalable framework for continual learning. Proceedings of the 35th International Conference on Machine Learning, 4528-4537.
Shi, X., Mueller, J., Erickson, N., Li, M., & Smola, A. (2021). Benchmarking multimodal AutoML for tabular data with text fields. arXiv preprint arXiv:2111.02705.
Subbaswamy, A., & Saria, S. (2020). From development to deployment: Dataset shift, causality, and shift-stable models in health AI. Biostatistics, 21(2), 345-352.
van de Ven, G. M., & Tolias, A. S. (2019). Three scenarios for continual learning. arXiv preprint arXiv:1904.07734.
von Oswald, J., Henning, C., Sacramento, J., & Grewe, B. F. (2020). Continual learning with hypernetworks. Proceedings of the 8th International Conference on Learning Representations.
Wang, F., Kaushal, R., & Khullar, D. (2020). Should health care demand interpretable artificial intelligence or accept “black box” medicine? Annals of Internal Medicine, 172(1), 59-60.
Wortsman, M., Ramanujan, V., Liu, R., Kembhavi, A., Rastegari, M., Yosinski, J., & Farhadi, A. (2020). Supermasks in superposition. Advances in Neural Information Processing Systems, 33, 15173-15184.
Yoon, J., Yang, E., Lee, J., & Hwang, S. J. (2018). Lifelong learning with dynamically expandable networks. Proceedings of the 6th International Conference on Learning Representations.
Zenke, F., Poole, B., & Ganguli, S. (2017). Continual learning through synaptic intelligence. Proceedings of the 34th International Conference on Machine Learning, 3987-3995.
Zhang, J., Zhang, J., Ghosh, S., Li, D., Tasci, S., Heck, L., … & Hakkani-Tür, D. (2020). Taskmaster-1: Toward a realistic and diverse dialog dataset. Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing, 4516-4525.
Zhao, H., Des Combes, R. T., Zhang, K., & Gordon, G. (2019). On learning invariant representations for domain adaptation. Proceedings of the 36th International Conference on Machine Learning, 7523-7532.
Zhu, Y., Zhuang, F., Wang, J., Ke, G., Chen, J., Bian, J., … & He, Q. (2020). Deep subdomain adaptation network for image classification. IEEE Transactions on Neural Networks and Learning Systems, 32(4), 1713-1722.