Tackling Non-forgetting and Forward Transfer with a Uniﬁed Lifelong Learning Approach
Abstract
Humans are the best example of agents that can learn a variety of skills incrementally over the course of their lives, and imbuing machines with this skill is the goal of lifelong machine learning.
Ideally, lifelong learning should achieve nonforgetting, forward and backward transfer, avoid confusion,support few-shot learning, and so on.
In previous approaches, the focus has been given to subsets of these properties, often by ﬁtting together an array of separate mechanisms.
In this work, we propose a simple yet powerful uniﬁed framework that supports almost all of these properties through one central consolidation mechanism.
We then describe a particular instance of this framework designed to support non-forgetting and forward transfer.
This novel approach works by efﬁciently locating sparse neural sub-networks and controlling their consolidation during lifelong learning.
1. Introduction
The past decade has seen signiﬁcant growth in the capabilities of artiﬁcial intelligence.
Deep learning in particular has achieved great successes in medical image recognition and diagnostics (Litjens et al., 2017;
Shen et al., 2017), tasks on natural language processing (Radford et al., 2019; Devlin et al., 2019), difﬁcult games (Silver et al., 2017) and even farming (Kamilaris & Prenafeta-Bold´u, 2018).
However, deep learning models almost always need thousands or millions of training samples to perform well.
This is in a sharp contrast with human learning, which normally learns a new concept with a small number of samples.
Two other major weaknesses in current deep learning when compared to human learning, as conveyed in Figure 1, include difﬁculty in learning many tasks sequentially without forgetting previous ones and leveraging previous learned knowledge to better acquire new knowledge.
Human
Machine
Nonforgetting
Forward transfer
Old task
New task
Old task
New task
Old task
New task
Old task
New task
[Figure]
Humans are generally able to learn new tasks without forgetting old ones and use old tasks to better learn new ones.
However, machine learning is susceptible to forgetting previous tasks and being unable to transfer knowledge to new tasks.
Even more learning properties are discussed in Section 2.2.
Image of brain sourced from https://www.injurymap.
com/free-human-anatomy-illustrations under CC license.
Several lines of research in supervised learning exist to overcome these weaknesses.
Multi-task learning (Caruana, 1997) considers how to learn multiple concepts at the same time such that they help each other to be learned better.
The related ﬁeld of transfer learning (Pan & Yang, 2009) assumes that some concepts have been previously learned and we would like to transfer their knowledge to assist learning new concepts.
Few-shot learning (Fei-Fei et al., 2006) aims to learn tasks with a small number of labeled data.
Lifelong learning (Thrun, 1998; Thrun., 1995) (LLL – also known as continual (Parisi et al., 2019) or sequential learning (McCloskey & Cohen, 1989)) considers how to learn and transfer skills across long sequences of tasks.
However, most previous approaches can only demonstrate subsets of these human-like properties, often by different complex mechanisms.
For example, existing lifelong learning (LLL) techniques tend to use one or more of three types of mechanisms, each of which comes with their own drawbacks and hurdles (De Lange et al., 2019).
These mechanisms are based on replay, regularization, and dynamic architecture respectively.
See Section 2.3 for overviews of these mechanisms.
We wish to ﬁnd a learning framework with one central mechanism that can seamlessly implement many desirable properties.
In this paper, we propose a uniﬁed approach that brings lifelong machine learning closer to human learning by supporting many desirable properties.
This uniﬁed framework, described in Section 3, places weight consolidation as the central mechanism to achieve many lifelong learning properties.
A more extensive description of this framework is provided in (Ling & Bohn, 2019).
Starting from this uniﬁed framework, we then describe a speciﬁc novel approach to
LLL.
This approach works by identifying the sub-networks critical to performance on each learned class (inspired by the lottery ticket hypothesis (Frankle & Carbin, 2018)) and intelligently using this information to inform weight consolidation policies.
Our primary contributions are:
• We describe a conceptual uniﬁed LLL framework which is designed to display many desirable learning properties with a single central mechanism (see Section 3).
• We describe a particular lifelong learning approach which works by identifying sub-networks critical to individual classes in order to intelligently control weight consolidation (see Section 4).
• We demonstrate that by changing a small number of hyperparameters, our approach can achieve nonforgetting and support forward transfer (see Section 5).
2. Background
In this section we will ﬁrst describe our lifelong learning (LLL) setting.
Second, we will discuss a broad set of important LLL properties.
Third, we will provide an overview of common mechanisms employed by LLL approaches.
2.1. Lifelong Learning Setting
In our lifelong setting, we consider the task-incremental classiﬁcation tasks, where batches of data for new tasks arrive sequentially.
That is, a sequence of ( T 1 , D 1 ) , ( T 2 , D 2 ) , ... are given, where D i is the labeled training data of task
T i (from the space of tasks T ), and an individual task consists of a set of classes to be learned.
Classiﬁcation models for ( T 1 , T 2 , ..., ( T k must be functional before ( T k +1 , D k +1 ) arrives.
This models the incremental process of human lifelong learning.
This LLL setting can be easily extended to other learning settings such as multi-task learning where all T i and D i are given at the same time.
It can also be extended to metalearning where the knowledge learned for T i only provides a starting point to learn T j more effectively.
Additionally, it can be extended to curriculum learning where T i are able to be ordered from “simple” to “complex” based on a given difﬁculty metric.
2.2. Lifelong Learning Properties
Here we discuss at a high level several properties a LLL approach would ideally exhibit.
In this particular work, we design an approach with the ﬁrst three properties in mind.
Continual learning and testing : Before starting to learn a new task T j , a LLL approach should be able to perform well on all T i<j .
While learning the new task T j , LLL should only use data D j .
This is a startling contrast with the standard multi-task (batch) learning where data of all tasks are used for training at the same time.
This ensures that the model will be consistently useful when continually learning tasks with high computational and data efﬁciency.
See Section 3.2 for details.
Non-forgetting : This is the ability to avoid catastrophic forgetting (McCloskey & Cohen, 1989), where learning T j causes a dramatic loss in performance on one or more T i<j .
Ideally, learning T j using only the data of T j would not affect T i<j .
Due to the tendency towards catastrophic forgetting, non-lifelong learning approaches would require retraining on data for all tasks together to avoid forgetting.
This may reduce computational and data efﬁciency.
A property opposite to non-forgetting is graceful forgetting (Aljundi et al., 2018), as often seen in humans.
Learning new tasks may require additional model capacity, and when this is not possible, the model can perform graceful forgetting of unimportant tasks to free up capacity for new tasks.
See
Section 3.3 for details.
Forward transfer : This is the ability to learn new tasks,
T ≥ i , easier and better following earlier learned tasks T <i , also known as knowledge transfer (Pan & Yang, 2009).
See
Section 3.4 for details.
Few-shot learning : Achieving sufﬁcient forward transfer opens the door to few-shot learning of later concepts.
Backward transfer : This is knowledge transfer from T ≥ i to T <
i – the opposite direction as forward transfer.
When learning new tasks T j they may in turn help to improve the performance of T i<j .
This is like an “overall review” before a ﬁnal exam after materials of all chapters have been taught and learned.
Later materials can often help better understand earlier materials.
Adapting to concept update/drift : This is the ability to continually perform well at a given task T i by utilizing additional training data for T i if it arrives at a later time (concept updating), or when new data for the changing environment arrives (concept drift).
This process should only use the data of T i to update the model while not forgetting other learned tasks.
Non-confusion : Machine learning algorithms often ﬁnd the minimal set of discriminating features necessary for classiﬁcation.
Thus, when more tasks emerge for learning in
our
LLL setting, earlier learned features may not be sufﬁcient, leading to confusion between classes.
For example, after learning to distinguish between images of “1” and “0” as Tand T 2 , the learned model may identify straight stroke for class “1” and curved stroke for “0”.
But after learning “I” and “O” as T 10 and T 11 for example without using data for “0” and “1”, the model may confuse between T 1 and T(“1” and “I”) and similarly between T 2 and T 11 (“0” and “O”) when the model is tested on all tasks learned so far.
In human lifelong learning, this type of confusion may happen too.
For example, when meeting new people, if the ﬁrst two people are visually distinct (such as very tall vs. very short) we can rely on this feature to tell them apart.
However, if more people arrive and they are similar to the ﬁrst two people, we may initially confuse them and must ﬁnd ﬁner details to reduce confusion, or to uniquely distinguish them.
In the extreme case where we encounter identical twins, signiﬁcant effort may be required to learn the necessary details (by re-using their facial image data).
Human-like learning :
As a new type of evaluation criteria for LLL, we can consider how well an approach is predictive of human learning behaviour.
If a LLL approach or framework is also able to provide explanatory power and match peculiarities of human learning (such as confusion or knowledge transfer in certain scenarios), it would have value in ﬁelds outside of machine learning.
2.3. Overview of Different LLL Approaches
The mechanisms used to perform LLL tend to fall into three categories and often only demonstrate subsets of LLL properties as previously discussed.
The ﬁrst mechanism, replay, commonly works by storing previous task data and training on it alongside new task data (Rebufﬁ et al., 2017; Isele & Cosgun, 2018; Chaudhry et al., 2019; Wu et al., 2019).
As a result of its data and computation inefﬁciency, we consider it generally not to be very a human-like learning mechanism.
The second mechanism is regularization.
This mechanism works by restricting weight changes (making them less “ﬂexible”) via a loss function so that learning new tasks does not signiﬁcantly affect previous task performance (Kirkpatrick et al., 2016; Zenke et al., 2017b; Chaudhry et al., 2018; Ritter et al., 2018; Li & Hoiem, 2017; Zhang et al., 2020).
We use this mechanism as the basis for our uniﬁed framework.
However, instead of simply controlling weight ﬂexibility to retain previous task performance, we leverage it to also encourage forward transfer.
The third mechanism, dynamic architecture, commonly works by adding new weights for each task and only allowing those to be tuned (Rusu et al., 2016; Yoon et al., 2018; Xu & Zhu, 2018).
This is often done without requiring previous task data and completely reduces forgetting while also allowing previous task knowledge to speed up learning of the new task.
While this mechanism is necessary for LLL of an arbitrarily long sequence of tasks (any ﬁxedsize network will eventually reach maximum capacity), it should be used sparingly to avoid unnecessary computational costs.
Our particular approach, described in Section 4, can control the rate at which the representational capacity of the neural network is used up, so that longer task sequences may be accommodated.
3. A Uniﬁed Framework for LLL
In this section we describe how our uniﬁed framework works.
We start by introducing the central mechanism and in the rest of the section, discuss how to use the central mechanism to support the multiple desirable LLL properties described in Section 2.2.
For a more extensive treatment on achieving these properties with this uniﬁed framework, see (Ling & Bohn, 2019).
In the pseudo-codes provided, the lines where the central mechanism is applied is marked by a (cid:32) .
In Section 4 we discuss a particular realization of this framework to experiment on.
3.1. A Central Consolidation Mechanism
We propose a lifelong learning framework which situates a consolidation policy as the central mechanism.
The consolidation policy works through a single dynamic hyperparameter, bbb , which separately controls the ﬂexibility of all network weights.
In other words, each weight in the network can have its own consolidation value, representing how easy (or hard) it is to modify the weight.
Depending on the speciﬁc bbb -setting policy used during training, several desirable learning properties can be achieved.
While the individual weights of the network are learned via back-propagation, bbb is set by a consolidation policy (which depends on the speciﬁc approach).
The central consolidation mechanism ultimately works through dynamically modifying the loss function.
To describe more precisely, we will deviate a little from the no- tation used in (Kirkpatrick et al., 2016), which introduced the Elastic Weight Consolidation LLL approach.
If each network weight, θ i , is associated with a consolidation value of bbb i ≥ 0 , the loss for the new task by itself, L t , is combined with weight consolidation as follows:
[Equation]
Here, θ targeti is the target value for a weight to be changed to.
This can be either its value before training of the new task, or zero, in the case where we explicitly want to prevent certain weights from being used.
θ ti is the weight value being updated during training on task t .
The loss now had the following behaviour: a large bbb i value indicates that changing weight
θ i away from θ targeti is strongly penalized during training.
When a set of weights have large corresponding b b b values, we will often refer to them as “frozen” .
In contrast, value of bbb i = 0 indicates that the weight is free to change.
We refer to these weights as “unfrozen” .
If bbb i is arbitrarily large, we can consider θ i to be masked during backpropagation and completely prevented from changing to improve efﬁciency.
3.2. Continual Learning of New Classiﬁcation Tasks
In both lifelong and human learning, we desire to learn new tasks after learning previous tasks.
In humans, this is enabled by the ability to continually grow new connections between neurons and remove old connections.
When this ability is compromised, so is our ability to learn new things.
Similarly, in our conceptual framework we consider learning new tasks with the help of network expansion and pruning.
The pseudo-code in Algorithm 1 describes how to learn a new task, T k , in a deep neural network in our conceptual framework after previous tasks T 1 , ...
T k − 1 have been learned.
The role of the consolidation policy in this algorithm (and all others in this paper), as marked by (cid:32) , is to ensure that newly added weights have the proper ﬂexibility and that previous task weights will be inﬂexible, to prevent forgetting (Section 3.3).
This is a very general, high-level framework, and in subsequent sections, several of the steps in Algorithm 1 will be explained and expanded upon.
3.3. Non-Forgetting Maintaining performance on previous classiﬁcation tasks
while learning new concepts is the primary difﬁculty lifelong learning approaches aim to combat.
In our framework, we can design consolidation policies to make sure previous tasks will not be forgotten while the new task is learned with the data for the new task only.
An intuitive way to prevent indicates
// Given that tasks T 1 , ..., T k − 1 have been learned
Recruit free units for T k // this can be all available units, or determined by the task difficulty and similarity with previous tasks.
See
Section 3.
(cid:32)
Initialize weights from earlier units to newly recruited units // see green links in Fig.
2 and relating to forward transfer, see
Section 3.
(cid:32)
Initialize weights for the new units // see blue links in Fig.(cid:32)
Set consolidation values for non-forgetting of previous tasks // see red links in Fig.
For non-forgetting, see Section 3.
Train the new task T k to minimize Eq.
1 // only on the data of new task T k (cid:32)
Optionally prune the network for T k // prune to free units for future tasks and graceful forgetting).
forgetting is by using a larger bbb value for weights which most inﬂuence the loss of a trained model (Kirkpatrick et al., 2016).
Our framework is inspired by the inﬂuential Elastic Weight
Consolidation (EWC) (Kirkpatrick et al., 2016), which essentially uses the second derivative of the loss with respect to each weight as the weight consolidation value.
Intuitively, well-learned previous classiﬁcation tasks usually have a sharp local minimum (compared with a randomly-initialized network for the new task), thus, have relatively large second derivatives and bbb values.
However, in our framework, bbb can be set to any large values based on the policy (to be designed), which controls how much non-forgetting should occur, based on desired applications.
If bbb is set to inﬁnitely large, then forgetting would not happen at all, and this is equivalent to training a separate new network for the new classiﬁcation task.
Pseudo-code reﬂecting how a consolidation policy can simply be used in our framework is given in Algorithm 2.
The role of the consolidation policy here, similar to in Algorithm 1, is to prevent weights for previous tasks from being changed, but allowing the new task weights to change.
3.4. Forward Transfer
While Section 3.3 ensures previous tasks will not be forgotten during learning the new task, the previous tasks do not “help” learning the new task, a concept prominent in
[Figure]
Algorithm 2 Non-forgetting // We need to learn a new task T k by using data for only T k , without forgetting T 1 ...T k −(cid:32)
Unfreeze only units for T k // blue and green
links
in Fig.
2 with bbb set to small values
(cid:32)
Freeze all weights for tasks { T 1 ...
T k − 1 } // red
links
in Fig.
2, with bbb set to large values
Train the new task T k to minimize Eq.multi-task and transfer learning (Pan & Yang, 2009; Zhang & Yang, 2017), and appears in LLL as “forward transfer”. However, the question of how to utilize the previous task skills to accelerate new learning is a difﬁcult and ongoing research question.
In this conceptual framework discussion, we refer to the function estimating how much one task can be expected to help learn another as simply “similarity”, sim : T × T −→ [ − 1 , 1] .
This function is not necessarily commutative (i.e. sim ( T i , T j ) (cid:54)≡ sim ( T j , T i ) 1 ).
If a new task is very similar (or identical in the extreme case) according to some metric such as visual similarity, ( sim ≈ 1 ) then the new task can be learned with no or little training data (few-shot learning).
In other cases, previous tasks may actually impair the new task learning ( sim < 0 ).
As summarized in Algorithm 3, positive forward transfer in our framework may be achieved through initialization of the weights for current task based on its similarity with previous tasks.
For example, when initializing the outputlayer weights for a new task, if the new task T k is identical to a previous task T j , then we can initialize the weights of
T k to reﬂect the values of those for T j , requiring no or few new units for T k .
This idea is conceptually similar to that used by GO-MTL (Kumar & Daume III, 2012) and ELLA (Ruvolo & Eaton, 2013), where knowledge is selectively shared between related tasks.
The role of the consolidation policy here, is to further allow positive transference and limit negative transference by controlling ﬂexibility of weights between tasks (green links in Fig. 2). Algorithm 3 Forward Transfer
// Assume T 1 , ..., T k − 1 have been learned, and we need to transfer their knowledge while learning the new task
T k
[Equation]
Initialize weights for T k based on s // as weight initialization, see Fig. [Equation]
Set values of b b b for T k ’s links based on s Train the new task to minimize Eq.
[Figure]
[Equation] [Figure]
4. LLL with Non-forgetting and Forward Transfer
In this section we will describe a particular LLL approach based on our uniﬁed framework which is designed to support non-forgetting and forward transfer with the single consolidation mechanism.
While the framework described in Section 3 is not concerned with how exactly to determine which weights of a neural network “belong” to a given task, that is the function we discuss ﬁrst in Section 4.1.
In Sections 4.2 and 4.3 we then describe consolidation strategies for non-forgetting and forward transfer respectively.
4.1. Identifying Critical Sub-networks (Lottery Tickets)
Central to our approach is the ability to identify a critical sub-network associated with each class learned by a neural network, where each class is associated with a single output dimension.
We refer to these sub-networks as lottery tickets (LTs), taking inspiration from the lottery ticket hypothesis (Frankle & Carbin, 2018).
The visual intuition behind our approach to identifying LTs is provided in Figure 4 – where the ﬁnal LT weights for class 0 are shown with solid red edges in (e).
Our particular approach is designed so that even when very sparse sub-networks are chosen, our method guarantees the presence of a full path (from input to output nodes) and it is not easy for non-LT weights to inﬂuence the output of the corresponding LT class.
To identify the weights making up a LT, we ﬁrst obtain the rescaled magnitudes of all weights such that for each node, n , the maximum weight magnitude pointing to it is 1 :
[Equation]
where in ( n ) is the set of weights pointing into a node.
Next, we recursively identify the LT nodes in a network for class index c :
N c
[Equation]
where N ( l ) is the set of important nodes for layer l , out ( · ) and in ( · ) are correspondingly the set of weights pointing out of and into of any nodes in the argument, and τ ∈ [0 , 1] is the pruning threshold that deﬁnes how sparse the selected sub-networks are.
The base case of N c ( depth ) =
{ c } is seen in Figure 4 as the highlighted output node for which the LT is identiﬁed.
Given N , the set of LT weights for class c is ﬁnally deﬁned by:
[Equation]
For the biases of a layer, the same condition is used.
After the LT for a class has been identiﬁed, the set of weight locations responsible are stored in memory.
Given a LT, we deﬁne three speciﬁc types of weights: central LT weights, backward-incidental weights, and forwardincidental weights.
Central LT weights are weights feeding into LT nodes which have normalized magnitudes > τ , backward-incidental weights are those feeding into LT nodes which have normalized magnitudes < τ , and forwardincidental weights are those leading out of LT nodes into non-LT nodes.
4.2. Non-forgetting
By design, LTs are critical for a neural networks performance on their respective classes and tasks.
It follows that by preventing the weights of the LTs for a task from changing, the performance on the task can been maintained.
We can implement this kind of weight-change penalty with b and Equation 1 as described in Section 3.1.
The particular consolidation policy we use to achieve non-forgetting is:
[Equation]
where C is the set of classes that have already undergone training.
In other words, a consolidation value of b nf ≥is applied to central and backward-incidental LT weights, and b fw ≥ 0 is applied to forward-incidental weights.
Given a ﬁxed pruning value, τ , modulating b nf allows us to control how strongly past skills are maintained.
Modulating b
fw however, has a larger effect on forward transfer, which we discuss next.
4.3. Forward Transfer
The ability to transfer knowledge from previous tasks to new ones, known as forward transfer, allows for more efﬁciently learning tasks later in a sequence.
In our approach, forward transfer is supported by proper ﬂexibility of forwardincidental weights (dashed green edges in Figure 4).
In the consolidation policy described in Equation 5, this corresponds to small b fw values.
We also suspect that it will be important to ensure a sufﬁcient amount of free weights for learning a new task by increasing the sparsity of LTs (corresponding to larger values for τ ).
5. Experimental Setups and Results
For each of non-forgetting and forward transfer, we discuss the relevant metric, task, and then examine the experimental results.
For both experiments presented, we evaluate on the
Split-MNIST task sequence (Zenke et al., 2017a), which consists of ﬁve tasks: 0 vs 1, 2 vs 3, etc.
Task orders are shufﬂed across trials for these experiments to remove any [Figure] [Figure] confounding effects potentially caused by particular task orders.
Additional hyperparameters and settings for the experiments are provided in Table5.
. Non-forgetting
Metric .
Catastrophic forgetting refers to the tendency for a neural network to forget old skills as new ones are presented.
Given a sequence of tasks to solve, the extent of catastrophic forgetting (the opposite of non-forgetting) can be measured with backward transfer interference ( BTI ) (Riemer et al., 2018), which is the average difference between the retained accuracy ( RA ) of each task and the learned accuracy ( LA ).
The LA for a task is the test accuracy as measured immediately after the task is learned, while RA is the test accuracy as measured after all tasks have been learned.
Intuitively, catastrophic forgetting will cause the retained accuracy for old tasks to be much smaller than the learned accuracy.
When BTI < 0 , we consider forgetting (or negative backward transfer) to have occurred.
When BTI > 0 (old task skills improve as new ones are presented) we consider positive backward transfer to have occurred.
In this work, we will report a normalized backward transfer interference score, nBTI :
[Equation]
The nBTI allows us to put models on a more equal footing when comparing backward transfer/non-forgetting.
Consider the following two models whose error rates suffer proportionally from forgetting: (1) where
LA = 0 . 99 and
RA = 0 .
98 ( BTI = − 0 . 01 ), and (2) where LA = 0 . 9 and
RA = 0 .
8 ( BTI = − 0 . 1 ).
For both models, nBTI = − 100% , indicating that the error rate doubles.
In our nonforgetting experiment, nBTI is calculated using multi-head evaluation, so that at test time, the task index is known to the model.
Experiment: pruning and LT consolidation .
Figuredemonstrates how τ and b nf can work together for nonforgetting.
As we expect, there is a clear trend for nonforgetting to improve as consolidation of LT weights increases in strength.
However, once τ is below 0.95, nBTI does not appear to be sensitive to changes in the hyperparameter.
For experimental setup, refer to non-forgetting in
Table 1.
[Figure]
5.2. Forward Transfer
Metric .
Forward transfer refers to the ability for a model to learn new skills more easily by utilizing previously learning knowledge (and possibly with fewer weights needed) as
[Table]
more tasks are learned.
To measure forward transfer, we build off of FTI (forward transfer and interference)
(LopezPaz & Ranzato, 2017), which is the difference between the
LA for a task in the lifelong setting, and the LA for a task when learned independently ( LA non LLL ).
When FTI < 0 , we consider negative forward transfer to occur, and when
FTI > 0 we consider positive forward transfer to occur.
However, to make the metric independent of the overall performance of the model, we report a normalized forward transfer metric:
[Equation]
To provide some intuition behind this augmented forward transfer metric: when nFTI = − 1 : using the lifelong learning approach causes the learned error for each task to increase by 100% (2X worse), when nFTI = 0 , using nonLLL is the same as LLL with regard to learned accuracy, and when nFTI = 0 .
5 : learned errors rates are decreased by half.
Experiment: sparsity and consolidation .
In Figure 6, we can observe the effect of τ and consolidation on nFTI .
Most notably, when b nf = 0 , or τ is near 1, nFTI is maximized.
In contrast, this is when nBTI is minimized.
Additionally, nFTI does prove to be sensitive to b fw , especially when b nf is large, suggesting that when forward-incidental weights are not free to adapt to the new task, modifying LT weights sufﬁces.
6. Conclusions
In this work, we presented a uniﬁed framework for lifelong learning that can be used to display may properties with a single central mechanism.
Starting from this conceptual framework, we then describe a concrete approach designed to support non-forgetting and forward transfer.
In particular, the approach performs weight consolidation guided by identiﬁed critical sub-networks – which we refer to as LTs.
This approach tackles a difﬁcult problem that captures multiple important aspects of human learning.
Future work includes improving the sub-network identiﬁcation algorithm to better support both non-forgetting and forward transfer at the same time, and implementing further consolidation-based skills as outlined in (Ling & Bohn, 2019).
Progress in this area [Table] is critical for the development of computationally efﬁcient and ﬂexible machine learning algorithms.