E FFICIENT A RCHITECTURE S EARCH FOR C ONTINUAL L EARNING
Anonymous authors
Paper under double-blind review
A BSTRACT
Continual learning with neural networks is an important learning framework in
AI that aims to learn a sequence of tasks well.
However, it is often confronted with three challenges: (1) overcome the catastrophic forgetting problem, (2) adapt the current network to new tasks, and meanwhile (3) control its model complexity.
To reach these goals, we propose a novel approach named as Continual Learning with Efﬁcient Architecture Search, or CLEAS in short.
CLEAS works closely with neural architecture search (NAS) which leverages reinforcement learning techniques to search for the best neural architecture that ﬁts a new task.
In particular, we design a neuron-level NAS controller that decides which old neurons from previous tasks should be reused (knowledge transfer), and which new neurons should be added (to learn new knowledge).
Such a ﬁne-grained controller allows ﬁnding a very concise architecture that can ﬁt each new task well.
Meanwhile, since we do not alter the weights of the reused neurons, we perfectly memorize the knowledge learned from previous tasks.
We evaluate CLEAS on numerous sequential classiﬁcation tasks, and the results demonstrate that CLEAS outperforms other state-of-the-art alternative methods, achieving higher classiﬁcation accuracy while using simpler neural architectures.
I NTRODUCTION
Continual learning, or lifelong learning, refers to the ability of continually learning new tasks and also performing well on learned tasks.
It has attracted enormous attention in AI as it mimics a human learning process - constantly acquiring and accumulating knowledge throughout their lifetime (Parisi et al., 2019).
Continual learning often works with deep neural networks (Javed & White, 2019;
Nguyen et al., 2017; Xu & Zhu, 2018) as the ﬂexibility in a network design can effectively allow knowledge transfer and knowledge acquisition.
However, continual learning with neural networks usually faces three challenges.
The ﬁrst one is to overcome the so-called catastrophic forgetting problem (Kirkpatrick et al., 2017), which states that the network may forget what has been learned on previous tasks.
The second one is to effectively adapt the current network parameters or architecture to ﬁt a new task, and the last one is to control the network size so as not to generate an overly complex network.
In continual learning, there are two main categories of strategies that attempt to solve the aforementioned challenges.
The ﬁrst category is to train all tasks within a network with ﬁxed capacity.
For example, (Rebufﬁ et al., 2017; Lopez-Paz & Ranzato, 2017; Aljundi et al., 2018) replay some old samples with the new task samples and then learn a new network from the combined training set.
The drawback is that they typically require a memory system that stores past data.
(Kirkpatrick et al., 2017; Liu et al., 2018) employ some regularization terms to prevent the re-optimized parameters from deviating too much from the previous ones.
Approaches using ﬁxed network architecture, however, cannot avoid a fundamental dilemma - they must either choose to retain good model performances on learned tasks, leaving little room for learning new tasks, or compromise the learned model performances to allow learning new tasks better.
To overcome such a dilemma, the second category is to expand the neural networks dynamically (Rusu et al., 2016; Yoon et al., 2018; Xu & Zhu, 2018).
They typically ﬁx the parameters of the old neurons (partially or fully) in order to eliminate the forgetting problem, and also permit adding new neurons to adapt to the learning of a new task.
In general, expandable networks can achieve better model performances on all tasks than the non-expandable ones.
However, a new issue appears: expandable networks can gradually become overly large or complex, which may break the limits of the available computing resources and/or lead to over-ﬁtting.
In this paper, we aim to solve the continual learning problems by proposing a new approach that only requires minimal expansion of a network so as to achieve high model performances on both learned tasks and the new task.
At the heart of our approach we leverage Neural Architecture Search (NAS) to ﬁnd a very concise architecture to ﬁt each new task.
Most notably, we design NAS to provide a neuron-level control.
That is, NAS selects two types of individual neurons to compose a new architecture: (1) a subset of the previous neurons that are most useful to modeling the new task; and (2) a minimal number of new neurons that should be added.
Reusing part of the previous neurons allows efﬁcient knowledge transfer; and adding new neurons provides additional room for learning new knowledge.
Our approach is named as Continual Learning with Efﬁcient Architecture Search, or
CLEAS in short.
Below are the main features and contributions of CLEAS.
• CLEAS dynamically expands the network to adapt to the learning of new tasks and uses NAS to determine the new network architecture; • CLEAS achieves zero forgetting of the learned knowledge by keeping the parameters of the previous architecture unchanged; • NAS used in CLEAS is able to provide a neuron-level control which expands the network minimally.
This leads to an effective control of network complexity; • The RNN-based controller behind CLEAS is using an entire network conﬁguration (with all neurons) as a state.
This state deﬁnition deviates from the current practice in related problems that would deﬁne a state as an observation of a single neuron.
Our state deﬁnition leads to improvements of 0.31%, 0.29% and 0.75% on three benchmark datasets.
• If the network is a convolutional network (CNN), CLEAS can even decide the best ﬁlter size that should be used in modeling the new task.
The optimized ﬁlter size can further improve the model performance.
We start the rest of the paper by ﬁrst reviewing the related work in Section 2.
Then we detail our
CLEAS design in Section 3.
Experimental evaluations and the results are presented in Section 4.
R ELATED W ORK
Continual Learning Continual learning is often considered as an online learning paradigm where new skills or knowledge are constantly acquired and accumulated.
Recently, there are remarkable advances made in many applications based on continual learning: sequential task processing (Thrun, 1995), streaming data processing (Aljundi et al., 2019), self-management of resources (Parisi et al., 2019; Diethe et al., 2019), etc.
A primary obstacle in continual learning, however, is the catastrophic forgetting problem and many previous works have attempted to alleviate it.
We divide them into two categories depending on whether their networks are expandable.
The ﬁrst category uses a large network with ﬁxed capacity.
These methods try to retain the learned knowledge by either replaying old samples (Rebufﬁ et al., 2017; Rolnick et al., 2019; Robins, 1995) or enforcing the learning with regularization terms (Kirkpatrick et al., 2017; Lopez-Paz &
Ranzato, 2017; Liu et al., 2018; Zhang et al., 2020).
Sample replaying typically requires a memory system which stores old data.
When learning a new task, part of the old samples are selected and added to the training data.
As for regularized learning, a representative approach is Elastic Weight
Consolidation (EWC) (Kirkpatrick et al., 2017) which uses the Fisher information matrix to regularize the optimization parameters so that the important weights for previous tasks are not altered too much.
Other methods like (Lopez-Paz & Ranzato, 2017; Liu et al., 2018; Zhang et al., 2020) also address the optimization direction of weights to prevent the network from forgetting the previously learned knowledge.
The major limitation of using ﬁxed networks is that it cannot properly balance the learned tasks and new tasks, resulting in either forgetting old knowledge or acquiring limited new knowledge.
To address the above issue, another stream of works propose to dynamically expand the network, providing more room for obtaining new knowledge.
For example, Progressive Neural Network (PGN) (Rusu et al., 2016) allocates a ﬁxed number of neurons and layers to the current model for a new task.
Apparently, PGN may end up generating an overly complex network that has high redundancy and it can easily crash the underlying computing system that has only limited resources.
Another approach DEN (Dynamically Expandable Network) (Yoon et al., 2018) partially mitigates the issue of PGN by using group sparsity regularization techniques.
It strategically selects some old neurons to retrain, and adds new neurons only when necessary.
However, DEN can have the forgetting problem due to the retraining of old neurons.
Another drawback is that DEN has very sensitive hyperparameters that need sophisticated tuning.
Both of these algorithms only grow the network and do not have a neuron level control which is a signiﬁcant departure from our work.
Most recently, a novel method RCL (Reinforced Continual Learning)
(Xu & Zhu, 2018) also employs NAS to expand the network and it can further decrease model complexity.
The main difference between RCL and CLEAS is that RCL blindly reuses all the neurons from all of the previous tasks and only uses NAS to decide how many new neurons should be added.
However, reusing all the old neurons has two problems.
First, it creates a lot of redundancy in the new network and some old neurons may even be misleading and adversarial; second, excessively many old neurons reused in the new network can dominate its architecture, which may signiﬁcantly limit the learning ability of the new network.
Therefore, RCL does not really optimize the network architecture, thus it is unable to generate an efﬁcient and effective network for learning a new task.
By comparison, CLEAS designs a ﬁne-grained NAS which provides neuron-level control.
It optimizes every new architecture by determining whether to reuse each old neuron and how many new neurons should be added to each layer.
Neural Architecture Search NAS is another promising research topic in the AI community.
It employs reinforcement learning techniques to automatically search for a desired network architecture for modeling a speciﬁc task.
For instance, Cai et al.
(Cai et al., 2018) propose EAS to discover a superb architecture with a reinforced meta-controller that can grow the depth or width of a network;
Zoph et al.
(Zoph & Le, 2016) propose an RNN-based controller to generate the description of a network, and the controller is reinforced by the predicting accuracy of a candidate architecture.
Pham et al.
(Pham et al., 2018) propose an extension of NAS, namely ENAS, to speed up training processing by forcing all child networks to share weights.
Apart from algorithms, NAS also has many valuable applications such as image classiﬁcation (Real et al., 2019; Radosavovic et al., 2019), video segmentation (Nekrasov et al., 2020), text representation (Wang et al., 2019) and etc.
Hence, NAS is a demonstrated powerful tool and it is especially useful in continual learning scenarios when one needs to determine what is a good architecture for the new task.
M ETHODOLOGY
There are two components in the CLEAS framework: one is the task network that continually learns a sequence of tasks; and the other is controller network that dynamically expands the task network.
The two components interact with each other under the reinforcement learning context - the task network sends the controller a reward signal which reﬂects the performance of the current architecture design; the controller updates its policy according to the reward, and then generates a new architecture for the task network to test its performance.
Such interactions repeat until a good architecture is found.
Figure 1 illustrates the overall structure of CLEAS.
On the left is the task network, depicting an optimized architecture for task t − 1 (it is using gray and pink neurons) and a candidate architecture for task t .
They share the same input neurons but use their own output neurons.
Red circles are newly added neurons and pink ones are reused neurons from task t − 1 (or any previous task).
To train the network, only the red weights that connect new-old or new-new neurons are optimized.
On the right is the controller network which implements an RNN.
It provides a neuron-level control to generate a description of the task network design.
Each blue square is an RNN cell that decides to use or drop a certain neuron in the task network.
[Figure]
3. N EURAL A RCHITECTURE S EARCH M ODEL
Task Network
The task network can be any neural network with expandable ability, for example, a fully connected network or a CNN, etc.
We use the task network to model a sequence of tasks.
Formally, suppose there are T tasks and each has a training set D t
= { ( x i , y i ) }
O t i =1 , a validation set V t
=
( x i , y i ) } M t i =1 and a test set T t = { ( x i , y i ) } K t i =1 , for t = 1 , 2 , . . .
, T .
We denote by A t the network architecture that is generated to model task t .
Moreover, we denote A t =
( N t , W t )
where
N t are the neurons or ﬁlters used in the network and W t are the corresponding weights.
We train the ﬁrst task with a basic network A 1 by solving the standard supervised learning problem
[Equation]
where L 1 is the loss function for the ﬁrst task.
For the optimization procedure, we use stochastic gradient descent (SGD) with a constant learning rate.
The network is trained till the required number of epochs or convergence is reached.
When task t ( t > 1 ) arrives, for every task k < t we already know its optimized architecture
A k and parameters W k .
Now we use the controller to decide a network architecture for task t .
Consider a candidate network A t =
( N t , W t ) .
There are two types of neurons in N t : N old t are used neurons from previous tasks and N newt = N t \ N oldt are the new neurons added.
Based on this partition, the weights W t can be also divided into two disjoint sets: W oldt are the weights that connect only used neurons, and W newt =
W t \ W oldt are the new weights that connect old-new or new-new neurons.
Formally, N oldt = { n ∈ N t | there exists k < t such that n ∈ N k } and W oldt = { w ∈ W t | there exists n 1 , n 2 ∈ N oldt such that w connects n 1 , n 2 } .
The training procedure for the new task is to only optimize the new weights W newt and leave W oldt unchanged, equal to their previously optimized values W oldt .
Therefore, the optimization problem for the new task reads
[Equation]
Then we set W t =
( W oldt , W newt ) .
Finally, this candidate network A t with optimized weights
W t is tested on the validation set V t .
The corresponding accuracy and network complexity is used to compute a reward R (described in Section 3.2).
The controller updates its policy based on
R and generates a new candidate network A (cid:48) t to repeat the above procedure.
After enough such interactions, the candidate architecture that achieves the maximal reward is the optimal one for task t , i.e. A t =
( N t , W t ) , where N t ﬁnally denotes the neurons of the optimal architecture.
Controller Network
The goal of the controller is to provide a neuron-level control that can decide which old neurons from previous tasks can be reused, and how many new neurons should be added.
In our actual implementation, we assume there is a large hyper-network for the controller to search for a task network.
Suppose the hyper-network has l layers and each layer i has a maximum of u i neurons.
Each neuron has two actions, either “drop” or “use” (more actions for CNN, to be described later).
Thus, the search space for the controller would be 2 n where n = (cid:80) li =1 u
i is the total number of neurons.
Apparently, it is infeasible to enumerate all the action combinations and determine the best one.
To deal with this issue, we treat the action sequence as a ﬁxed-length string a 1: n = a 1 , a 2 , . .
. , a n that describes a task network.
We design the controller as an LSTM network where each cell controls one a i in the hyper-network.
Formally, we denote by π ( a 1: n | s 1: n ; θ c ) the policy function of the controller network as
[Equation]
The state s 1: n is a sequence that represents one state; the output is the probability of a task network described by a 1: n ; and θ c denotes the parameters of the controller network.
At this point we note that our model is a departure from standard models where states are considered individual s j and an episode is comprised of s 1: n .
In our case we deﬁne s 1: n as one state and episodes are created by starting with different initial states (described below).
Recall that in Fig.1, the two components in CLEAS work with each other iteratively and there are
H · U such iterations where H is the number of episodes created and U the length of each episode.
Consider an episode e
= ( s 11: n , ¯ a 11: n , R 1 , s 21: n , ¯ a 21: n , R 2 , . . .
, s U 1: n , ¯ a U 1: n , R U , s U +1 1: n ) .
The initial state s 11: n is either generated randomly or copied from the terminal state s U +1 1: n of the previous episode.
The controller starts with some initial θ c .
For any u = 1 , 2 , . . .
, U , the controller generates the most probable task network speciﬁed by ¯ a u 1: n from s u 1: n by following LSTM.
To this end, we use the recursion a uj = f
( s uj , h uj − 1 ) where h uj − 1 is the hidden vector and f standard LSTM equations to generate a u 1: n from s u 1: n .
Let us point out that our RNN application a uj =
f
( s uj , h uj − 1 ) differs from the standard practice that uses a uj = f ( a uj − 1 , h uj − 1 ) .
Action ¯ a u 1: n is obtained from a u 1: n by selecting the maximum probability value for each j,≤ j ≤ n .
The task trains this task network, evaluates it on the validation set and returns reward R u .
We then construct s u +11: n from the previous neuron action ¯ a uj together with the layer index as b u +1 j for each 1 ≤ j ≤ n .
More concretely, s u +1 j
[Equation]
where ¯ a uj , b uj have been one-hot encoded, and ⊕ is the concatenation operator.
Finally, a new network architecture ¯ a u +11: n is generated from s u +11: n .
At the end of each episode, the controller updates its parameter θ c by a policy gradient algorithm.
After all H · U total iterations, the task network that achieves the maximum reward is used for that task.
The choice for treating the state as s 1: n and not s j has the following two motivations.
In standard
NAS type models after updating s j the network is retrained.
This is intractable in our case as the number of neurons n is typically large.
For this reason we want to train only once per s 1: n .
The second reason is related and stems from the fact that the reward is given only at the level of s 1: n .
For this reason it makes sense to have s 1: n as the state.
This selection also leads to computational improvements as is attested later in Section 4.
CLEAS-C for CNN
The design of CLEAS also works for CNN with ﬁxed ﬁlter sizes where one ﬁlter corresponds to one neuron.
However, we know that ﬁlter sizes in a CNN can have a huge impact on its classiﬁcation accuracy.
Therefore, we further improve CLEAS so that it can decide the best ﬁlter sizes for each task.
In particular, we allow a new task to increase the ﬁlter size by one upon the previous task.
For example, a ﬁlter size 3 × 3 used in some convolutional layer in task t − 1 can become 4 × 4 in the same layer in task t .
Note that for one task all the ﬁlters in the same layer must use the same ﬁlter size, but different layers can use different ﬁlter sizes.
We name the new framework as CLEAS-C. There are two major modiﬁcations to CLEAS-C. First, the output actions in the controller are now encoded by 4 bits and their meanings are “only use,”“use & extend,”“only drop” and “drop & extend” (see Fig. 2).
Note that the extend decision is made at the neuron layer, but there has to be only one decision at the layer level.
To this end, we apply simple majority voting of all neurons at a layer to get the layer level decision.
The other modiﬁcation regards the training procedure of the task network.
The only different case we should deal with is how to optimize a ﬁlter (e.g. 4 × 4 ) that is extended from a previous smaller ﬁlter (e.g. 3 × 3 ).
Our solution is to preserve the optimized parameters that are associated with the original smaller ﬁlter (the 9 weights) and to only optimize the additional weights (the 16 − 9 = 7 weights).
The preserved weights are placed in the center of the larger ﬁlter, and the additional weights are initialized as the averages of their surrounding neighbor weights.
[Figure]
3. T RAINING WITH REINFORCE
Lastly, we present the training procedure for the controller network.
Note that each task t has an independent training process so we drop subscript t here.
Within an episode, each action string a u 1: n represents a task architecture and after training gets a validation accuracy A u .
In addition to accuracy, we also penalize the expansion of the task network in the reward function, leading to the ﬁnal reward
[Equation]
where C is the number of newly added neurons, and α is a trade-off hyperparameter.
With such episodes we train
[Equation]
by using REINFORCE.
We use an exponential moving average of the previous architecture accuracies as the baseline.
We summarize the key steps of CLEAS in Algorithm 1 where H is the number of iterations, U is the length of episodes, and p is the exploration probability.
We point out that we do not strictly follow the usual (cid:15) -greedy strategy; an exploration step consists of starting an epoch from a completely random state as opposed to perturbing an existing action.
Conﬁgure the task network as
A u based on ¯ a u 1: n and train weights W u on D t ; Evaluate A u with trained W u on V t and compute reward R u ; Construct s u +11: n from ¯ a u 1: n and b u 1: n where b u 1: n is the layer encoding; Update θ c by REINFORCE using ( s 11: n , ¯ a 11: n , R 1 , . . .
, s U 1: n , ¯ a U 1: n , R U , s U +1 1: n ) ;
Store A h =
( N ¯ u , W ¯ u ) where ¯ u = arg max u R u and ¯ R h = max u R u ; Store A t =
A ¯ h where ¯ h = arg max h ¯ R h ;
E XPERIMENTS
We evaluate CLEAS and other state-of-the-art continual learning methods on MNIST and CIFARdatasets.
The key results delivered are model accuracies, network complexity and training time.
All methods are implemented in Tensorﬂow and ran on a GTX1080Ti GPU unit.
4. D ATASETS AND B ENCHMARK A LGORITHMS
We use three benchmark datasets as follows.
Each dataset is divided into T = 10 separate tasks.
MNIST-associated tasks are trained by fully-connected neural networks and CIFAR-100 tasks are trained by CNNs.
(a) MNIST Permutation (Kirkpatrick et al., 2017): Ten variants of the MNIST data, where each task is transformed by a different (among tasks) and ﬁxed (among images in the same task) permutation of pixels.
(b) Rotated MNIST (Xu & Zhu, 2018):
Another ten variants of MNIST, where each task is rotated by a different and ﬁxed angle between 0 to 180 degree.
(c) Incremental CIFAR-100 (Rebufﬁ et al., 2017):
The original CIFAR-100 dataset contains 60,000 32 × 32 colored images that belong to 100 classes.
We divide them into 10 tasks and each task contains 10 different classes and their data.
We select four other continual learning methods to compare.
One method ( MWC ) uses a ﬁxed network architecture while the other three use expandable networks.
(1) MWC: An extension of EWC (Kirkpatrick et al., 2017).
By assuming some extent of correlation between consecutive tasks it uses regularization terms to prevent large deviation of the network weights when re-optimized.
(2) PGN: Expands the task network by adding a ﬁxed number of neurons and layers (Rusu et al., 2016).
(3) DEN: Dynamically decides the number of new neurons by performing selective retraining and network split (Yoon et al., 2018).
(4) RCL:
Uses NAS to decide the number of new neurons.
It also completely eliminates the forgetting problem by holding the previous neurons and their weights unchanged (Xu & Zhu, 2018).
For the two MNIST datasets, we follow (Xu & Zhu, 2018) to use a three-layer fully-connected network.
We start with 784-312-128-10 neurons with RELU activation for the ﬁrst task.
For CIFAR100, we develop a modiﬁed version of LeNet (LeCun et al., 1998) that has three convolutional layers and three fully-connected layers.
We start with 16 ﬁlters in each layer with sizes of 3 × 3 , 3 ×and 4 × 4 and stride of 1 per layer.
Besides, to fairly compare the network choice with (Xu & Zhu, 2018; Yoon et al., 2018), we set: u i = 1000 for MNIST and u i = 128 for CIFAR-100.
We also use H = 200 and U = 1 .
The exploration probability p is set to be 30%.
We select the RMSProp optimizer for REINFORCE and Adam for the training task.
We also implement a version with states corresponding to individual neurons where the controller is following a uj = f ( a uj − 1 , h uj − 1 ) .
We conﬁgure this version under the same experimental settings as of CLEAS and test it on the three datasets.
The results show that compared to CLEAS, this version exhibits an inferior performance of -0.31% , -0.29% , -0.75% in relative accuracy, on the three datasets, respectively.
Details can be found in Appendix.
4. E XPERIMENTAL R ESULTS
[Figure]
Model Accuracy We ﬁrst report the averaged model accuracies among all tasks.
Fig.3 shows the relative improvements of the network-expandable methods against EWC (numbers on the top are their absolute accuracies).
We clearly observe that methods with expandability can achieve much better performance than MWC.
Furthermore, we see that CLEAS outperforms other methods.
The average relative accuracy improvement of CLEAS vs RCL (the state-of-the-art method and the second best performer) is 0.21% , 0.21% and 6.70% , respectively.
There are two reasons: (1) we completely overcome the forgetting problem by not altering the old neurons/ﬁlters; (2) our neuron-level control can precisely pick useful old neurons as well as new neurons to better model each new task.
Network Complexity Besides model performance, we also care about how complex the network is when used to model each task.
We thus report the average number of model weights across all tasks in Fig.
First, no surprise to see that MWC consumes the least number of weights since its network is non-expandable.
But this also limits its model performance.
Second, among the other four methods that expand networks we observe CLEAS using the least number of weights.
The average relative complexity improvement of CLEAS vs RCL is 29.9% , 19.0% and 51.0% reduction, respectively.
It supports the fact that our NAS using neuron-level control can ﬁnd a very efﬁcient architecture to model every new task.
Network Descriptions
We visualize some examples of network architectures the controller generates.
Fig.
5 illustrates four optimal conﬁgurations (tasks 2 to 5) of the CNN used to model CIFAR-100.
Each task uses three convolutional layers and each square represents a ﬁlter.
A white square means it is not used by the current task; a red square represents it was trained by some earlier task and now reused by the current task; a light yellow square means it was trained before but not reused; and a dark yellow square depicts a new ﬁlter added.
According to the ﬁgure, we note that CLEAS tends to maintain a concise architecture all the time.
As the task index increases it drops more old ﬁlters and only reuses a small portion of them that are useful for current task training, and it is adding fewer new neurons.
CLEAS-C We also test CLEAS-C which decides the best ﬁlter sizes for CNNs.
In the CIFARexperiment, CLEAS uses ﬁxed ﬁlter sizes 3 × 3 , 3 × 3 and 4 × 4 in its three convolutional layers.
By comparison, CLEAS-C starts with the same sizes but allows each task to increase the sizes by one.
The results show that after training the 10 tasks with CLEAS-C the ﬁnal sizes become 4 × 4 , 8 × 8 , and 8 × 8 .
It achieves a much higher accuracy of 67.4% than CLEAS ( 66.9% ), i.e. a 0.7% improvement.
It suggests that customized ﬁlter sizes can better promote model performances.
On the other hand, complexity of CLEAS-C increases by 92.6%.
[Figure]
Neuron Allocation We compare CLEAS to RCL on neuron reuse and neuron allocation.
Fig.visualizes the number of reused neurons (yellow and orange for RCL; pink and red for CLEAS) and new neurons (dark blue for both methods).
There are two observations.
On one hand, CLEAS successfully drops many old neurons that are redundant or useless, ending up maintaining a much simpler network.
On the other hand, we observe that both of the methods recommend a similar number of new neurons for each task.
Therefore, the superiority of CLEAS against RCL lies more on its selection of old neurons.
RCL blindly reuses all previous neurons.
[Figure]
[Figure]
Training Time We also report the training time in Fig.7.
It is as expected that CLEAS’ running time is on the high end due to the neuron-level control that results in using a much longer RNN for the controller.
On the positive note, the increase in the running time is not substantial.
Hyperparameter Sensitivity We show the hyperparameter analysis in Appendix.
The observation is that the hyperparameters used in CLEAS are not as sensitive as those of DEN and RCL.
Under all hyperparameter settings CLEAS performs the best.
C ONCLUSIONS
We have proposed and developed a novel approach CLEAS to tackle continual learning problems.
CLEAS is a network-expandable approach that uses NAS to dynamically determine the optimal architecture for each task.
NAS is able to provide a neuron-level control that decides the reusing of old neurons and the number of new neurons needed.
Such a ﬁne-grained control can maintain a very concise network through all tasks.
Also, we completely eliminate the catastrophic forgetting problem by never altering the old neurons and their trained weights.
With demonstration by means of the experimental results, we note that CLEAS can indeed use simpler networks to achieve yet higher model performances compared to other alternatives.
In the future, we plan to design a more efﬁcient search strategy or architecture for the controller such that it can reduce the runtime while not compromising the model performance or network complexity.