Encoder Based Lifelong Learning

TL;DR

This paper presents an autoencoder-based lifelong learning method that mitigates catastrophic forgetting by preserving task-specific features, enabling a single model to learn multiple tasks sequentially with reduced performance loss.

Contribution

Introduces a novel autoencoder-based approach for lifelong learning that preserves previous task knowledge while allowing adaptation to new tasks.

Findings

Reduces catastrophic forgetting compared to existing methods

Effective on image classification tasks

Maintains performance on previous tasks while learning new ones

Abstract

This paper introduces a new lifelong learning solution where a single model is trained for a sequence of tasks. The main challenge that vision systems face in this context is catastrophic forgetting: as they tend to adapt to the most recently seen task, they lose performance on the tasks that were learned previously. Our method aims at preserving the knowledge of the previous tasks while learning a new one by using autoencoders. For each task, an under-complete autoencoder is learned, capturing the features that are crucial for its achievement. When a new task is presented to the system, we prevent the reconstructions of the features with these autoencoders from changing, which has the effect of preserving the information on which the previous tasks are mainly relying. At the same time, the features are given space to adjust to the most recent environment as only their projection into a low dimension submanifold is controlled. The proposed system is evaluated on image classification tasks and shows a reduction of forgetting over the state-of-the-art

Tables

Table 1. Table 1: Classification accuracy for the Two Tasks scenario starting from ImageNet. For the first task, the reference performance is given by Feature extraction. For the second task, we consider Finetuning as the reference as it is the best that can be achieved by one task alone.

	ImageNet $\to$ Scenes				ImageNet $\to$ Birds				ImageNet $\to$ Flowers				Average loss
	Acc. on Task1		Acc. on Task2		Acc. on Task1		Acc. on Task2		Acc. on Task1		Acc. on Task2		Task 1	Task 2
Finetuning	48.0%	(-9%)	65.0%	(ref)	41.3%	(-15.7%)	59.0%	(ref)	50.8%	(-6.2%)	86.4%	(ref)	-10.3%	(ref)
Feature extraction	57.0%	(ref)	60.6%	(-4.4%)	57.0%	(ref)	51.6%	(-7.4%)	57.0%	(ref)	84.6%	(-1.8%)	(ref)	-4.5%
LwF	55.4%	(-1.6%)	65.0%	(-0%)	54.4%	(-2.6%)	58.9%	(-0.1%)	55.6%	(-1.4%)	85.9%	(-0.5%)	-1.9%	-0.2%
Ours	56.3%	(-0.7%)	64.9%	(-0.1%)	55.3%	(-1.7%)	58.2%	(-0.8%)	56.5%	(-0.5%)	86.2%	(-0.2%)	-1.0%	-0.4 %
Ours - separate FCs	57.0%	(-0%)	65.9%	(+0.9%)	57.0%	(-0%)	57.7%	(-1.3%)	56.5%	(-0.5%)	86.4%	(-0%)	-0.2%	-0.1 %

Table 2. Table 2: Classification accuracy for the Two Tasks scenario starting from Flowers. For the first task, the reference performance is given by Feature extraction. For the second task, we consider Finetuning as reference as it is the best that can be achieved by one task alone.

	Flowers $\to$ Scenes				Flowers $\to$ Birds				Average loss
	Acc. on Task1		Acc. on Task2		Acc. on Task1		Acc. on Task2		Task 1	Task 2
Finetuning	61.6%	(-24.8%)	63.9%	(ref)	66.6%	(-19.8%)	57.5%	(ref)	-22.3%	(ref)
Feature extraction	86.4%	(ref)	59.6%	(-4.3%)	86.4%	(ref)	48.6%	(-8.9%)	(ref)	-6.6%
LwF	83.7%	(-2.7%)	62.2%	(-1.7%)	82.0 %	(-4.4%)	52.2 %	(-5.3%)	-3.6%	-3.5%
Ours	84.9%	(-1.5%)	62.3%	(-1.6%)	83.0%	(-3.4%)	52.0 %	(-5.5%)	-2.4%	-3.5%
Ours - separate FCs	86.4%	(-0%)	63.0%	(-0.9%)	85.4%	(-1.0%)	55.1%	(-2.4%)	-0.5%	-1.6%

Table 3. Table 3: Classification accuracy for the Three Tasks scenario starting from ImageNet. Ours achieves the best trade off between the tasks in the sequence with less forgetting to the previous tasks.

	ImageNet	Scenes	Birds	Average Acc.
Finetuning	37.5%	45.6%	58.1%	47.2%
LwF	53.3%	63.5%	57.2 %	58.0%
Ours	54.9%	64.7%	56.9%	58.8%

Table 4. Table 4: Classification accuracy for the Three Tasks scenario starting from Flowers. Ours achieves the best trade off between the tasks in the sequence with less forgetting to the previous tasks.

	Flowers	Scenes	Birds	Average Acc.
Finetuning	51.2%	48.1%	58.5%	51.6%
LwF	81.1%	59.1%	52.3%	64.1%
Ours	82.8%	61.2 %	51.2%	65.0%

Table 5. Table 5: Showing that F 𝐹 F and r 𝑟 r are contractive: Mean MSE of 50 samples from random Gaussian distribution, of their corresponding features and reconstructions over 500 trails - The main model and the AE are trained on Flowers dataset. As we move from left to right in the table, the entries in the columns decrease significantly verifying that the mappings are contractive.

	Samples	Features	Reconstructions
Exp. 1	229.98	33.05	0.21
	$\pm 0.065$	$\pm 0.066$	$\pm 0.0024$
Exp. 2	10176.54	106.60	0.21
	$\pm 41.17$	$\pm 0.32$	$\pm 0.0027$

Table 6. Table 6: Showing that F 𝐹 F and r 𝑟 r are contractive: Mean MSE of 50 samples from random Gaussian distribution, of their corresponding features and reconstructions over 500 trails - The main model and the AE are trained on Imagenet dataset. As we move from left to right in the table, the entries in the columns decrease significantly verifying that the mappings are contractive.

	Samples	Features	Reconstructions
Exp. 1	230.02	9.48	1.55
	$\pm 0.063$	$\pm 0.022$	$\pm 0.01$
Exp. 2	10173.11	61.29	2.12
	$\pm 41.35$	$\pm 0.18$	$\pm 0.013$

Table 7. Table 7: Size of the used autoencoders compared to the size of the models during training. The model size corresponds to the required memory during training. The feature size corresponds to the length of the feature extractor output.

Model	Size	Feature size	Autoencoder size
AlexNet	449 MB	9216	10 MB (2.2%)
VGG	1.1 GB	25088	28 MB (2.5%)

Equations

$$\sum _{t=1}^{\mathcal{T}}{\mathbb{E}}_{({\mathcal{X}}^{(t)},{\mathcal{Y}}^{(t)})}[\ell (f_t({\mathcal{X}}^{(t)}),{\mathcal{Y}}^{(t)})],$$

$$\sum _{t=1}^{\mathcal{T}}\frac{1}{N_t}\sum _{i=1}^{N_t}\ell (f_t(X_i^{(t)}),Y_i^{(t)}),$$

$${\mathbb{E}}_{({\mathcal{X}}^{(1)})}[\ell (T_1\circ T\circ F({\mathcal{X}}^{(1)}),T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(1)}))]$$

$$\arg \underset{r}{\min }{\mathbb{E}}_{({\mathcal{X}}^{(1)},{\mathcal{Y}}^{(1)})}[$$

$$+\ell (T_1^{\ast }\circ T^{\ast }(r(F^{\ast }({\mathcal{X}}^{(1)}))),{\mathcal{Y}}^{(1)})],$$

$${\ell }_{dist}(\hat{\mathcal{Y}},{\mathcal{Y}}^{\ast })=-⟨{\mathcal{Z}}^{\ast },\log \hat{\mathcal{Z}}⟩$$

$${\mathcal{Z}}_i^{\ast }=\frac{{\mathcal{Y}}_i^{\ast 1/\theta }}{{\sum }_j{\mathcal{Y}}_j^{\ast 1/\theta }}\text{ and }{\hat{\mathcal{Z}}}_i=\frac{{\hat{\mathcal{Y}}}_i^{1/\theta }}{{\sum }_j{\hat{\mathcal{Y}}}_j^{1/\theta }}$$

$$\Vert r(x_1)-r(x_2){\Vert }_2\le \Vert W_{dec}{\Vert }_F\Vert \sigma (W_{enc}{x}_1)-\sigma (W_{enc}{x}_2){\Vert }_2.$$

$$\mathcal{R}$$

$$+{\ell }_{dist}(T_1\circ T\circ F({\mathcal{X}}^{(2)}),T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(2)}))$$

$$+\frac{\alpha }{2}\Vert \sigma (W_{enc}F({\mathcal{X}}^{(2)}))-\sigma (W_{enc}{F}^{\ast }({\mathcal{X}}^{(2)})){\Vert }_2^2].$$

$$R_N$$

$$+\sum _{t=1}^{\mathcal{T}-1}{\ell }_{dist}(T_t\circ T\circ F(X_i^{(\mathcal{T})}),T_t^{\ast }\circ T^{\ast }\circ F^{\ast }(X_i^{(\mathcal{T})}))$$

$$\displaystyle+\sum_{t=1}^{\mathcal{T}-1}\frac{\alpha_{t}}{2}\|\sigma(W_{enc,t}F(X_{i}^{(\mathcal{T})}))-\sigma(W_{enc,t}F^{*}(X_{i}^{(\mathcal{T})}))\|_{2}^{2}\Biggr{)}.$$

$$\forall (x,y),\Vert f(x)-f(y)\Vert \le K\Vert x-y\Vert$$

$$\mathcal{R}$$

$$+{\ell }_{dist}(T_1\circ T\circ F({\mathcal{X}}^{(2)}),T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(2)}))$$

$$+\frac{\alpha }{2}\Vert \sigma (W_{enc}F({\mathcal{X}}^{(2)}))-\sigma (W_{enc}{F}^{\ast }({\mathcal{X}}^{(2)})){\Vert }_2^2].$$

$$\mathbb{E}[\ell (T_2\circ T\circ F({\mathcal{X}}^{(2)}),{\mathcal{Y}}^{(2)}))]+\mathbb{E}[\ell (T_1\circ T\circ F({\mathcal{X}}^{(1)}),{\mathcal{Y}}^{(1)}))]$$

$$|\ell (T_1\circ T\circ$$

$$-\ell (T_1\circ T\circ F({\mathcal{X}}^{(2)}),T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(2)}))|$$

$$\le K_1\Vert F({\mathcal{X}}^{(1)})-F({\mathcal{X}}^{(2)})\Vert$$

$$+K_2\Vert {\mathcal{Y}}^{(1)}-T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(2)})\Vert .$$

$$\Vert {\mathcal{Y}}^{(1)}$$

$$\le \Vert {\mathcal{Y}}^{(1)}-T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(1)})\Vert$$

$$+\Vert T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(1)})-T_1^{\ast }\circ T^{\ast }\circ F^{\ast }({\mathcal{X}}^{(2)})\Vert$$

$$\Vert F({\mathcal{X}}^{(1)})-F({\mathcal{X}}^{(2)})\Vert$$

$$+\Vert F^{\ast }({\mathcal{X}}^{(1)})-r\circ F^{\ast }({\mathcal{X}}^{(1)})\Vert$$

$$+\Vert r\circ F^{\ast }({\mathcal{X}}^{(1)})-r\circ F^{\ast }({\mathcal{X}}^{(2)})\Vert$$

$$+\Vert r\circ F^{\ast }({\mathcal{X}}^{(2)})-r\circ F({\mathcal{X}}^{(2)})\Vert$$

$$+\Vert r\circ F({\mathcal{X}}^{(2)})-F({\mathcal{X}}^{(2)})\Vert .$$

$$\displaystyle K\Biggl{(}$$

$$+\sum _{t=2}^{\mathcal{T}}\Vert r_{t-1}\circ F({\mathcal{X}}^{(\mathcal{T})})-F({\mathcal{X}}^{(\mathcal{T})})\Vert$$

$$\displaystyle+\sum_{t=1}^{\mathcal{T}-2}\|r_{t}\circ F^{(*,\mathcal{T}-1)}(\mathcal{X}^{(t)})-r_{t}\circ F^{(*,t)}(\mathcal{X}^{(t)})\|\Biggr{)},$$

Full text

1 Introduction

Intelligent agents are able to perform remarkably well on individual tasks. However, when exposed to a new task or a new environment, such agents have to be retrained. In this process, they learn the specificity of the new task but tend to loose performance on the tasks they have learned before. For instance, imagine an agent that was trained to localize the defects on a set of factory products. Then, when new products are introduced and the agent has to learn to detect the anomalies in these new products, it faces the risk of forgetting the initial recognition task. This phenomenon is known as catastrophic forgetting [15, 20, 14, 6, 9]. It occurs when the datasets or the tasks are presented to the model separately and sequentially, as is the case in a lifelong learning setup [24, 25, 23].

The main challenge is to make the learned model adapt to new data from a similar or a different environment [18], without losing knowledge on the previously seen task(s). Most of the classical solutions for this challenge suffer from important drawbacks. Feature extraction (as in [5]), where the model / representation learned for the old task is re-used to extract features from the new data without adapting the model parameters, is highly conservative for the old task and suboptimal for the new one. Fine-tuning (as in [7]), adapts the model to the new task using the optimal parameters of the old task as initialization. As a result, the model is driven towards the newly seen data but forgets what was learned previously. Joint training (as in [4]) is a method where the model is trained jointly on previous and current tasks data. This solution is optimal for all tasks, but requires the presence of all the data at the same time. Such a requirement can be hard to meet, especially in the era of big data.

To overcome these drawbacks without the constraint of storing data from the previously seen tasks, two main approaches can be found in the literature. The first, presented in [13], proposes a way to train convolutional networks, where a shared model is used for the different tasks but with separate classification layers. When a new task is presented, a new classification layer is added. Then, the model is fine-tuned on the data of the new task, with an additional loss that incorporates the knowledge of the old tasks. This loss tries to keep the previous task predictions on the new data unchanged. Such a solution reduces the forgetting but is heavily relying on the new task data. As a consequence, it suffers from a build-up of errors when facing a sequence of tasks [1]. The work presented recently in [11] tackles the problem in a different way. Rather than having a data-oriented analysis, they consider the knowledge gained in the model itself, and transfer it from one task to another in a Bayesian update fashion. The method relies on approximating the weight distribution after training the model on the new task. A Gaussian distribution, for which the mean is given by the optimal weights for the first task, and the variance given by the diagonal of the Fisher information matrix is used as an approximation. Such a solution is based on a strong principle and gives interesting results. However, it requires to store a number of parameters that is comparable to the size of the model itself.

In this work, we propose a compromise between these two methods. Rather than heavily relying on the new task data or requiring a huge amount of parameters to be stored, we introduce the use of autoencoders as a tool to preserve the knowledge from one task while learning another. For each task, an undercomplete autoencoder is trained after training the task model. It captures the most important features for the task objective. When facing a new task, this autoencoder is used to ensure the preservation of those important features. This is achieved by defining a loss on the reconstructions made by the autoencoder, as we will explain in the following sections. In this manner, we only restrict a subset of the features to be unchanged while we give the model the freedom to adapt itself to the new task using the remaining capacity. Figure 1 displays the model we propose to use.

Below, we first give a short description of the most relevant related work in Sec. 2. Then, in Sec 3, we describe how to use the autoencoders to avoid catastrophic forgetting and motivate our choice by a short analysis that relates the proposed objective to the joint training scheme. In Sec. 4, we describe the experiments that we conducted, report and discuss their results before concluding in Sec. 5.

2 Related work

Our end goal is to train a single model that can perform well on multiple tasks, with tasks learned sequentially. This problem is at the intersection of Joint training (or multitask training) and Lifelong learning. Standard multi-task learning [4] aims to learn jointly from the data of the multiple tasks and uses inductive bias [16] in order to integrate the knowledge from the different domains in a single model. However, it requires the presence of data from all the tasks during training. In a lifelong learning scenario, on the other hand, tasks are treated in a sequential manner. The aim is then to exploit the knowledge from previous tasks while learning a new one. This knowledge is used to

(i) preserve the performance on the previously seen data,

(ii) improve this knowledge using inductive bias [16] from the new task data, and

(iii) act as a regularizer for the new task, which can be beneficial for the performance.

*In this work we aim at preserving the knowledge of the previous tasks and possibly benefiting from this knowledge while learning a new task, without storing data from previous tasks. *

Despite its potential benefits, this problem is under explored. Learning without forgetting (LwF), introduced in [13], proposes to preserve the previous performance through the knowledge distillation loss introduced in [10]. They consider a shared convolutional network between the different tasks in which only the last classification layer is task specific. When encountering a new task, the outputs of the existing classification layers given the new task data are recorded. During training, these outputs are preserved through a modified cross-entropy loss that softens the class probabilities in order to give a higher weight to the small outputs. More details about this loss and the method can be found in Sec. 3.2. This method reduces the forgetting, especially when the datasets come from related manifolds. Nevertheless, it has been shown by iCaRL: Incremental Classifier and Representation Learning  [21] that LwF suffers from a build up of errors in a sequential scenario where the data comes from the same environment. Similarly, Expert-gate [1] shows that the LwF performance drops when the model is exposed to a sequence of tasks drawn from different distributions. [21] proposes to store a selection of the previous tasks data to overcome this issue – something we try to avoid. The goal in [1] is to obtain experts for different tasks (instead of a single joint model shared by all tasks). They suggest a model of lifelong learning where experts on individual tasks are added to a network of models sequentially. The challenge then is to decide which expert to launch based on the input. Interestingly, they also use undercomplete autoencoders – in their case to capture the context of each task based on which a decision is made on which task the test sample belongs to. In this work, we build on top of LwF but reduce the cumulated errors using under-complete autoencoders learned on the optimal representations of the previous tasks.

Even more recently, another interesting solution to train shared models without access to the previous data, somewhat similar in spirit to our work, has been proposed in [11], in the context of reinforcement learning. The main idea of this method, called Elastic weight consolidation, is to constrain the weights $W_{i}$ while training for a second task with an additional loss $\sum_{i}\frac{\lambda}{2}F_{i}(W_{i}-W^{*}_{1,i})$ where $W^{*}_{1,i}$ are the optimal weights of the first task, and $F_{i}$ the diagonal terms of their Fisher information matrix. The use of the Fisher matrix prevents the weights that are important for the first task to change much. In our point of view, this method, despite its success, has two drawbacks. First, the method keeps the weights in a neighborhood of one possible minimizer of the empirical risk of the first task. However, there could be another solution that can give a better compromise between the two tasks. Second, it needs to store a large number of parameters that grows with the total number of weights and the number of tasks. For these reasons, rather than constraining the weights, we choose to constrain the resulting features, enforcing that those that are important for the previous tasks do not change much. By constraining only a sub-manifold of the features, we allow the weights to adjust so as to optimize the features for the new task, while preserving those that ensure a good performance on the previous tasks.

3 Overcoming forgetting with autoencoders

In this work, we consider the problem of training a supervised deep model that can be useful for multiple tasks, in the situation where at each stage the data fed to the network come always from one single task, and the tasks enter in the training scenario successively. The best performance for all the tasks simultaneously is achieved when the network is trained on the data from all the considered tasks at the same time (as in joint training). This performance is of course limited by the capacity of the used model, and can be considered an upper bound to what can be achieved in a lifelong learning setting, where the data of previous tasks is no longer accessible when learning a new one.

3.1 Joint training

In the following, we will use the notations $\mathcal{X}^{(t)}$ (model input) and $\mathcal{Y}^{(t)}$ (target) for the random variables from which the dataset of the task $t$ is sampled, and $X_{i}^{(t)}$ and $Y_{i}^{(t)}$ for the data samples. When we have access to the data from all $\mathcal{T}$ tasks jointly, the network training aims to control the statistical risk:

[TABLE]

by minimizing the empirical risk:

[TABLE]

where $N_{t}$ is the number of samples and $f_{t}$ the function implemented by the network for task $t$. For most of the commonly used models, we can decompose $f_{t}$ as $T_{t}\circ T\circ F$ where:

• •

$F$ is a feature extraction function (e.g. Convolutional layers in ConvNets)

• •

$T_{t}\circ T$ is a task operator. It can be for example a classifier or a segmentation operator. $T$ is shared among all tasks, while $T_{t}$ is task specific. (e.g. in ConvNets, $T_{t}$ could be the last fully-connected layer, and $T$ the remaining fully-connected layers.)

The upper part of Figure 1 gives a scheme of this general model. For simplicity, we will focus below on two-task training before generalizing to a multiple task scenario in section 3.4.

3.2 Shortcomings of Learning without Forgetting

As a first step, we want to understand the limitations of LwF [13]. In that work, it is suggested to replace in Eq (10) $\ell(T_{1}\circ\,T\circ\,F(\mathcal{X}^{(1)}),~{}\mathcal{Y}^{(1)})$     with      $\ell(T_{1}\circ\,T\circ\,F(\mathcal{X}^{(2)}),\\ T^{*}_{1}\circ\,T^{*}\circ\,F^{*}(\mathcal{X}^{(2)}))$, where $T^{*}_{1}\circ\,T^{*}\circ\,F^{*}$ is obtained from training the network on the first task. If we suppose that the model has enough capacity to integrate the knowledge of the first task with a small generalization error, then we can consider that

[TABLE]

is a reasonable approximation of $\mathbb{E}_{(\mathcal{X}^{(1)},\mathcal{Y}^{(1)})}[\ell(T_{1}\circ\,T\circ\,F(\mathcal{X}^{(1)}),\mathcal{Y}^{(1)})]$. However, in order to be able to compute the measure (3) using samples from $\mathcal{X}^{(2)}$, further conditions need to be satisfied.

In other terms, if we consider that $T_{1}\circ\,T\circ\,F$ tries to learn an encoding of the data in the target space $\mathcal{X}^{(1)}$, then one can say that the loss of information generated by the use of $\mathcal{X}^{(2)}$ instead of $\mathcal{X}^{(1)}$ is a function of the Kullback-Leibler divergence of the two related probability distributions, or equivalently of their cross-entropy. Thus, if the two data distributions are related, then LwF is likely to lead to high performance. If the condition of the relatedness of the data distributions fails, there is no direct guarantee that the use of $\ell(T_{1}\circ\,T\circ\,F(\mathcal{X}^{(2)}),T^{*}_{1}\circ\,T^{*}\circ\,F^{*}(\mathcal{X}^{(2)}))$ will not result in an important loss of information for the first task. Indeed, it has been shown empirically in [1] that the use of significantly different data distributions may result in a significant decrease in performance for LwF.

LwF is based on the knowledge distillation loss introduced in [10] to reduce the gap resulting from the use of different distributions. In this work, we build on top of the LwF method. In order to make the used approximation less sensitive to the data distributions, we see an opportunity in controlling $\|T_{1}\circ\,T\circ\,F(\mathcal{X}^{(1)})-T_{1}\circ\,T\circ\,F(\mathcal{X}^{(2)})\|$. Under mild conditions about the model functions, namely Lipschitz continuity, this control allows us to use $T_{1}\circ\,T\circ\,F(\mathcal{X}^{(2)})$ instead of $T_{1}\circ\,T\circ\,F(\mathcal{X}^{(1)})$ to better approximate the first task loss in Eq. (10). Note that the condition of continuity on which this observation is based is not restrictive in practice. Indeed, most of the commonly used functions in deep models satisfy this condition (e.g. sigmoid, ReLU).

Our main idea is to learn a submanifold of the representation space $F(\mathcal{X}^{(1)})$ that contains the most informative features for the first task. Once this submanifold is identified, if the projection of the features $F(\mathcal{X}^{(2)})$ onto this submanifold do not change much during the training of a second task, then two consequences follow:

(i) $F(\mathcal{X}^{(2)})$will stay informative for the first task during the training, and

(ii) at the same time there is room to adjust to the second task as only its projection in the learned submanifold is controlled.

Figure 2 gives a simplified visualization of this mechanism. In the next paragraphs, we propose a method to learn the submanifold of informative features for a given task using autoencoders.

3.3 Informative feature preservation

When beginning to train the second task, the feature extractor $F^{*}$ of the model is optimized for the first task. A feature extraction type of approach would keep this operator unchanged in order to preserve the performance on the previous task. This is, however, overly conservative, and usually suboptimal for the new task. Rather than preserving all the features during training, our main idea is to preserve only the features that are the most informative for the first task while giving more flexibility for the other features in order to improve the performance on the second task. An autoencoder [3] trained on the representation of the first task data obtained from an optimized model can be used to capture the most important features for this task.

3.3.1 Learning the informative submanifold with Autoencoders

An autoencoder is a neural network that is trained to reconstruct its input [8]. The network operates a projection $r$ that can be decomposed in an encoding and a decoding function. The optimal weights are usually obtained by minimizing the mean $\ell_{2}$ distance between the inputs and their reconstructions. If the dimension of the code is smaller than the dimension of the input (i.e. if the autoencoder is undercomplete), the autoencoder captures the submanifold that represents the best the structure of the input data. More precisely, we choose to use a two-layer network with a sigmoid activation in the hidden layer: $r(x)=W_{dec}\sigma(W_{enc}x).$ Figure 3 shows a general scheme of such an autoencoder.

Here, our aim is to obtain through the autoencoder a sub-manifold that captures the information that is not only important to reconstruct the features (output of the feature extraction operator $F^{*}$) of the first task, but also important for the task operator ($T^{*}_{1}\circ T^{*}$). The objective is:

[TABLE]

where $\ell$ is the loss function used to train the model on the first task data. $\lambda$ is a hyper-parameter that controls the compromise between the two terms in this loss. In this manner, the autoencoder represents the variations that are needed to reconstruct the input and at the same time contain the information that is required by the task operator.

3.3.2 Representation control with separate task operators

To explain how we use these autoencoders, we start with the simple case where there is no task operator shared among all tasks (i.e., $T=\emptyset$). The model is then composed of a common feature extractor $F$, and a task specific operator for each task $T_{t}$. Each time a new task is presented to the model, the corresponding task operator is then optimized. However, in order to achieve the aim of lifelong learning, we want to also update the feature extractor without damaging the performance of the model on the previously seen tasks.

In a two task scenario, after training the first task, we have $T_{1}^{*}$ and $F^{*}$ optimized for that task. Then, we train an undercomplete autoencoder using $F^{*}(X_{i}^{(1)})$ minimizing the empirical risk corresponding to (4). The optimal performance for the first task, knowing that the operator $T_{1}$ is kept equal to $T_{1}^{*}$, is obtained with $F$ equal to $F^{*}$.

Nevertheless, preventing $F$ from changing will lead to suboptimal performance on the second task. The idea here is to keep only the projection of $F$ into the manifold represented by the autoencoder ($r\circ~{}F$) unchanged. The second term of Eq. (4) explicitly enforces $r$ to represent the submanifold needed for good performance on task 1. Thus, controlling the distance between $r\circ F$ and $r\circ F^{*}$ will preserve the necessary information for task 1. From the undercompleteness of the encoder, $r$ projects the features into a lower dimensional manifold, and by controlling only the distance between the reconstructions, we give the features flexibility to adapt to the second task variations (cf. Figure 2).

3.3.3 Representation control with shared task operator

We now consider the model presented in Figure 1 where a part of the task operator is shared among the tasks as in the setting used in LwF [13]. This is clearly a preferrable architecture in a lifelong learning setting, as the memory increase when adding a new task is much lower. Our main idea is to start from the loss used in the LwF method and add an additional term coming from the idea presented in Sec. 3.3.2. Thus, in a two task scenario, in addition to the loss used for the second task, we propose to use two constraints:

The first constraint is the knowledge distillation loss ($\ell_{dist}$) used in [13]. If $\hat{\mathcal{Y}}:=T_{1}\circ T\circ F(\mathcal{X}^{(2)})$ and $\mathcal{Y}^{*}=T^{*}_{1}\circ T^{*}\circ F^{*}(\mathcal{X}^{(2)})$ then:

[TABLE]

where $\log$ is operated entry-wise and

[TABLE]

The application of a high temperature $\theta$ increases the small values of the output and reduces the weight of the high values. This mitigates the influence of the use of different data distributions. 2. 2.

The second constraint is related to the preservation of the reconstructions of the second task features ($r\circ F^{*}(\mathcal{X}^{(2)})$). The goal of this constraint is to keep $r\circ F$ close to $r\circ F^{*}$ as explained in Sec. 3.3.2.

For the second constraint, rather than controlling the distance between the reconstructions, we will here constrain the codes $\sigma(W_{enc}\cdot)$. From sub-multiplicity of the Frobenius norm, we have:

[TABLE]

The advantage of using the codes is their lower dimension. As the codes or reconstructions need to be recorded before beginning the training on the second task, using the codes will result in a better usage of the memory.

Finally, the objective for the training of the second task is the following:

[TABLE]

The choice of the parameter $\alpha$ will be done through model selection. An analysis of this objective is given in the appendix, giving a bound on the difference between $\mathbb{E}[\ell(T_{2}\circ~{}T\circ~{}F(\mathcal{X}^{(2)}),\mathcal{Y}^{(2)}))+\ell(T_{1}\circ T\circ F(\mathcal{X}^{(2)}),T_{1}^{*}\circ T^{*}\circ F^{*}(\mathcal{X}^{(2)}))]$ and the statistical risk in a joint-training setting (10). It shows that (9) effectively controls this bound.

3.4 Training procedure

The proposed method in Sec. 3.3.3 generalizes easily to a sequence of tasks. An autoencoder is then trained after each task. Even if the needed memory will grow linearly with the number of tasks, the memory required by an autoencoder is a small fraction of that required by the global model. For example, in the case of AlexNet as a base model, an autoencoder comprises only around 1.5% of the memory.

In practice, the empirical risk is minimized:

[TABLE]

The training is done using stochastic gradient descent (SGD) [2]. The autoencoder training is also done by SGD but with an adaptive gradient method, AdaDelta [28] which alleviates the need for setting the learning rates and has nice optimization properties. Algorithm 1 shows the main steps of the proposed method.

4 Experiments

We compare our method against the state-of-the-art and several baselines on image classification tasks. We consider sets of 2 and 3 tasks learned sequentially, in two settings: 1) when the first task is a large dataset, and 2) when the first task is a small dataset.

Architecture

We experiment with AlexNet [12] as our network architecture due to its widespread use and similarity to other popular architectures. The feature extraction block $F$ corresponds to the convolutional layers. By default, the shared task operator $T$ corresponds to all but the last fully connected layers (i.e., $fc6$ and $fc7$), while the task-specific part $T_{i}$ contains the last classification layer ($fc8$). During the training, we used an $\alpha$ of $10^{-3}$ for ImageNet and $10^{-2}$ for the rest of the tasks. Note that this parameter sets the trade off between the allowed forgetting on the previous task and the performance on the new task.

For the autoencoders, we use a very shallow architecture, to keep their memory footprint low. Both the encoding as well as the decoding consist of a single fully connected layer, with a sigmoid as non-linearity in between. The dimensionality of the codes is 100 for all datasets, except for ImageNet where we use a code size of 300. The size of the autoencoder is 3MB, compared to 250MB for the size of the network model. The training of the autoencoders is done using AdaDelta as explained in Sec. 3.4. During training of the autoencoders, we use a hyperparameter $\lambda$ (cf. Eq. (4)) to find a compromise between the reconstruction error and the classification error. $\lambda$ is tuned manually in order to allow the convergence of the code loss and the classification loss on the training data. Figure 4 shows the evolution of these losses for the training and validation samples of ImageNet during the training of an autoencoder based on the $conv5$ features extracted with AlexNet. In our experiments, $\lambda$ is set to $10^{-6}$ in all cases.

Datasets

We use multiple datasets of moderate size: MIT Scenes [19] for indoor scene classification (5,360 samples), Caltech-UCSD Birds [27] for fine-grained bird classification (5,994 samples) and Oxford Flowers [17] for fine-grained flower classification (2,040 samples). We excluded Pascal VOC as it is very similar to ImageNet, with subcategories of some of the VOC labels corresponding to ImageNet classes. These datasets were also used in both [1] and [13].

For the scenario based on a large initial dataset, we start from ImageNet (LSVRC 2012 subset) [22], which has more than 1 million training images. For the small dataset scenario, we start from Oxford Flowers, which has only 2,040 training and validation samples.

The reported results are obtained with respect to the test sets of Scenes, Birds and Flowers, and on the validation set of ImageNet. As in LwF [13], we need to record the targets for the old tasks before starting the training procedure for a new task. Here, we perform an offline augmentation with 10 variants of each sample (different crops and flips). This setting differs slightly from what has been done in [13], which explains the higher performance on the individual tasks in our experiments. We therefore compare against a stronger baseline than the accuracies reported in [13].

Compared Methods

We compare our method (Ours) with Learning without Forgetting (LwF) [13], which represents the current state-of-the-art. Additionally, we consider two baselines: Finetuning, where each model (incl. $F$ and $T$) is learned for the new task using the previous task model as initialization, and Feature extraction, where the weights of the previous task model ($F$ and $T$) are fixed and only the classification layer ($T_{t}$) is learned for each new task. Further, we also report results for a variant of our method, Ours - separate FCs where we only share the representation layers ($F$) while each task has its own fully connected layers (i.e., $T=\emptyset$ and $T_{i}=\{fc6-fc7-fc8\}$). This variant aims at finding a universal representation for the current sequence of tasks while allowing each task to have its own fully connected layers. With less sharing, the risk of forgetting is reduced, at the cost of a higher memory consumption and less regularization for new tasks. Note that in this case the task autoencoders can be used at test time to activate only the fully connected layers of the task that a test sample belongs to, in a similar manner to what was done in [1].

Setups

We consider sequences of 2 and 3 tasks. In the Two Tasks setup, we are given a model trained on one previously seen task and then add a second task to learn. This follows the experimental setup of LwF [13]. In their work, all the tested scenarios start from a large dataset, ImageNet. Here we also study the effect of starting from a small dataset, Flowers.111Due to the small size of the Flowers dataset, we use a network pretrained on ImageNet as initialization for training the first task model. The main difference hence lies in the fact that in this case we do not care about forgetting ImageNet. Further, we also consider a setup, involving Three Tasks. First, we use a sequence of tasks starting from ImageNet, i.e. ImageNet $\rightarrow$ Scenes $\rightarrow$ Birds. Additionally, we consider Flowers as a first task in the sequence Flowers $\rightarrow$ Scenes $\rightarrow$ Birds. Note that this is different from what was conducted in [13] where the sequences were only composed of splits of one dataset i.e. one task overall.

Results

Table 1 shows, for the different compared methods, the achieved performance on the Two Tasks scenario with ImageNet as the first task. While Finetuning is optimal for the second task, it shows the most forgetting of the first task. The performance on the second task is on average comparable for all methods except for Feature extraction. Since the Feature extraction baseline doesn’t allow the weights of the model to change and only optimizes the last fully connected layers, its performance on the second task is suboptimal and significantly lower than the other methods. Naturally the performance of the previous task is kept unchanged in this case. Ours - separate FCs shows the best compromise between the two tasks. The performance of the first task is highly preserved and at the same time the performance of the second task is comparable or better to the methods with shared FCs. This variant of our method has a higher capacity as it allocates separate fully connected layers for each task, yet its memory consumption increases more rapidly as tasks are added. Our method with a complete shared model Ours systematically outperforms the LwF method on the previous task and on average achieves a similar performance on the second task.

When we start from a smaller dataset, Flowers, the same trends can be observed, but with larger differences in accuracy (Table 2). The performance on the second task is lower than that achieved with ImageNet as a starting point for all the compared methods. This is explained by the fact that the representation obtained from ImageNet is more meaningful for the different tasks than what has been finetuned for Flowers. Differently from the ImageNet starting case, Ours - separate FCs achieves a considerably better performance on the second task than Ours and LwF while preserving the previous task performance. Finetuning shows the best performance on the second task while suffering from severe forgetting on the previous task. Indeed the pair of tasks here is of a different distribution and finding a compromise between the two is a challenging problem. As in the previous case Ours reduces the forgetting of LwF while achieving a similar average performance on the second task.

Overall, the Ours-separate FCs achieves the best performance on the different pairs of tasks. However, it requires allocating seprate fully connected layers for each task which requires a lot of memory. Thus, for the sequential experiments we focus on the shared model scenario.

In Table 3 we report the performance achieved by Ours, LwF and Finetuning for the sequence of ImageNet $\rightarrow$ Scenes $\rightarrow$ Birds. As expected the Finetuning baseline suffers from severe forgetting on the previous tasks. The performance on ImageNet (the first task) drops from 57% to 37.5% after finetuning on the third task. As this baseline does not consider the previous tasks in its training procedure it has the advantage of achieving the best performance on the last task in the sequence, as expected.

Ours continually reduces forgetting compared to LwF on the previous tasks while showing a comparable performance on the new task in the sequence. For example, Ours achieves 54.9% on ImageNet compared to 53.3% by LwF. Similar conclusions can be drawn regarding the sequential scenario starting from Flowers as reported in Table 4.

Behavior Analysis

To examine the effect of our representation control over the learning process, we perform an analysis on the distance between the representation obtained over the learning procedure and the one that is optimal for the first task. We use Flower $\rightarrow$ Scenes$\rightarrow$ Birds as a test case and compute the distance for each epoch between the current features of the Flowers dataset $F(\mathcal{X}^{1})$ and that obtained by the initial Flowers network $F^{*}(\mathcal{X}^{1})$, as shown in Figure 5. In the beginning of the training, the leading term in Eq. (8) is the loss related to the new task $\mathcal{T}$. Thus, in the first stage, the model is driven towards optimizing the performance of the most recent task. This results in a quick loss of performance for the previous tasks, and an increase in the other loss terms of the objective. Then, the second stage kicks in. In this stage, all the terms of Eq. (8) contribute and the model is pushed towards recovering its performance for the previous tasks while continuing improving for the most recent one. Gradually, $F(\mathcal{X}^{1})$ gets again closer to $F^{*}(\mathcal{X}^{1})$, until a new equilibrium is reached.

5 Conclusions and future work

Strategies for efficient lifelong learning is still an open research problem. In this work we tackled the problem of learning a sequence of tasks using only the data from the most recent environment, aiming at obtaining a reasonable performance on the whole sequence. Existing works consider solutions to preserve the knowledge of the previous tasks either by keeping the corresponding system predictions unchanged during training of the new task, or by keeping the model parameters in a neighborhood of the sequence of the previous optimal weights. While the first suffers from the difference in the task distributions, the second needs to store a large number of parameters.

The solution presented here reduces forgetting of earlier tasks by controlling the distance between the representations of the different tasks. Rather than preserving the optimal weights of the previous tasks, we propose an alternative that preserves the features that are crucial for the performance in the corresponding environments. Undercomplete autoencoders are used to learn the submanifold that represents these important features. The method is tested on image classification problems, in sequences of two or three tasks, starting either from a small or a large dataset. An improvement in performance over the state-of-the-art is achieved in all the tested scenarios. Especially, we showed a better preservation of the old tasks.

Despite the demonstrated improvements, this work also identifies possible further developments. A direction that is worth exploring is to use the autoencoders as data generators rather than relying on the new data. This would give a stronger solution in the situation where the new data does not represent previous distributions well.

Acknowledgment: The second equal author’s PhD is funded by an FWO scholarship. This work is partially funded by Internal Funds KU Leuven, FP7-MC-CIG 334380, and an Amazon Academic Research Award.

Appendix A Analysis of the main method

In this section, we present a detailed analysis of the main contribution of the paper and demonstrate its theoretical grounding.

The following derivations are based on the hypothesis that all the functions involved in the model training are Lipschitz continuous. The most commonly used functions such as sigmoid, ReLU or linear functions satisfy this condition. It is also the case for the most commonly used loss functions, e.g. softmax, logistic, or hinge losses. Note that squared and exponential losses are not Lipschitz continuous, but this is not a significant limitation as such losses are less frequently applied in practice due to their sensitivity to label noise.

Definition 1**.**

We say that a function $f$ is Lipschitz continuous if and only if there exist a constant $K$ such that:

[TABLE]

A.1 Relation between Encoder based Lifelong Learning and joint training

In the sequel, we use the same notation as in the main paper. In a two-task scenario, we propose to use the following objective to train a network using only the data from the second task:

[TABLE]

In the ideal case where we can keep in memory data from the first task, the best solution is to train the network jointly by minimizing the following objective:

[TABLE]

Proposition 1**.**

The difference between (10) and $\mathbb{E}[\ell(T_{2}\circ~{}T\circ~{}F(\mathcal{X}^{(2)}),\mathcal{Y}^{(2)}))+\ell(T_{1}\circ T\circ F(\mathcal{X}^{(2)}),T_{1}^{*}\circ T^{*}\circ F^{*}(\mathcal{X}^{(2)}))]$ can be controlled by the independent minimization of the knowledge distillation loss and five terms: (15), (16), (17), (18), and (19).

Proof.

From Lipschitz continuity, we deduce that the difference between (10) and $\mathbb{E}[\ell(T_{2}\circ~{}T\circ~{}F(\mathcal{X}^{(2)}),\mathcal{Y}^{(2)}))+\ell(T_{1}\circ T\circ F(\mathcal{X}^{(2)}),T_{1}^{*}\circ T^{*}\circ F^{*}(\mathcal{X}^{(2)}))]$ is bounded, and we can write for any vector norm $\|.\|$:

[TABLE]

(12) is related to the classification error on the first task. Indeed, using the triangle inequality, we can write:

[TABLE]

Note that all the terms on the right hand side of the inequality do not change during training of task 2, and thus cannot be controlled during the second training phase. Moreover, (13) depends only on the capacity of the network and is therefore not influenced by the encoder based lifelong learning scheme. (14) is the result of using $\mathcal{X}^{(2)}$ instead of $\mathcal{X}^{(1)}$. In order to reduce the effect of this shift, we use the knowledge distillation loss [10] as in the Learning without Forgetting (LwF) method [13].

On the other hand, expression (11) is bounded as well (using again the triangle inequality):

[TABLE]

This bound generalizes trivially to the expected value of the loss, which finishes the proof. ∎

Analyzing each of these terms individually, we see that our training strategy effectively controls the difference with the joint training risk:

• •

(16) is minimized through the autoencoder (AE) training and does not change during training of task 2.

• •

(17) does not change during training of task 2. Moreover, $\|~{}r\circ~{}F^{*}(\mathcal{X}^{(1)})~{}-~{}r\circ~{}F^{*}(\mathcal{X}^{(2)})\|$ measures the distance between two elements of the manifold that the AE represents. As the use of weight decay during training the task model makes the weights small, the projection of data into the feature space is contractive. Through our experiments, we observed that $r$ is also contractive. As a result, this distance is significantly smaller than $\|\mathcal{X}^{(1)}-\mathcal{X}^{(2)}\|$. The experiment in Sec. A.2 supports this observation.

• •

(18) is controlled during the training thanks to the second constraint we propose to use.

• •

(19) is the part of the features that we propose to relax in order to give space for the model to adjust to the second task as explained in Sec. 3.3 in the main text. Indeed, if we control this distance, the features are forced to stay in the manifold related to the first task. This will result in a stronger conservation of the first task performance, but the training model will face the risk of not being able to converge for the second task.

• •

(15) is a term that we cannot access during training. However, we observed that this distance is either decreasing or first increasing then decreasing during the training. An explanation of this behavior is that in the beginning $\ell(T_{2}\circ~{}T\circ~{}F(\mathcal{X}^{(2)}),\mathcal{Y}^{(2)}))$ may have a bigger influence on the objective, however, after decreasing the loss for the second task, $\ell(T_{1}\circ~{}T\circ~{}F(\mathcal{X}^{(2)}),T_{1}^{*}\circ~{}T^{*}\circ~{}F^{*}(\mathcal{X}^{(2)}))$ and $\|\sigma(W_{enc}F(\mathcal{X}^{(2)}))~{}-~{}\sigma(W_{enc}F^{*}(\mathcal{X}^{(2)}))\|_{2}$ tend to push $F$ towards $F^{*}$. Figure 5 in the main text, and the paragraph “Behavior analysis” support this observation.

This derivation motivates the code distance that we propose to use. It also elucidates the sources of possible divergence from joint-training.

A.2 Empirical study: $F$ and $r$ are contractive

This experiment aims to show empirically that $\|\mathcal{X}^{(1)}-\mathcal{X}^{(2)}\|$ is significantly larger than $\|r\circ F^{*}(\mathcal{X}^{(1)})-r\circ F^{*}(\mathcal{X}^{(2)})\|$ using the $\ell_{2}$ norm. To have empirical evidence for this observation, we conducted the following experiment:

First, we generate random inputs for the model from two different distributions. We use normal distributions with uniformly distributed means and variances. 2. 2.

Then, we compute the features of these inputs (output of $F$). 3. 3.

These features are fed to the AE to compute the reconstructions. 4. 4.

The mean squared error (MSE) between the samples, the features and the reconstructions are stored. 5. 5.

This procedure is repeated for several trials. Each time a different pair of distributions is used. Finally, the mean of the obtained MSE is computed.

We repeat this experiment twice. In the first instance, the mean and variance of the Gaussian distributions are generated in a way to have relatively small distances between the samples, and in the second we force the samples to have bigger distance. Tables 5 and  6 show the results of this experiment. The numbers in Table 5 are computed using AlexNet fine-tuned on Flowers dataset, and the AE trained as explained in Sec. 3.3 (in the main text) on the features of Flowers extracted using AlexNet convolutional layers after convergence. We report in this table the mean MSE and the error bars obtained with 50 generated samples from 500 different pairs of Gaussian distributions. The numbers in Table 6 are computed similarly but from the AlexNet and the AE related to ImageNet. In all cases, the difference between the samples is many orders of magnitude larger than the difference between the reconstructions indicating that the mapping is indeed contractive, and the residual error from this step is minimal.

A.3 Multiple task scenario

Each time a task is added, a new source of divergence from the joint-training objective is added. The difference with (10) grows with $\mathcal{T}$. Indeed, at each step, an extra irreducible $\|r\circ F^{*}(\mathcal{X}^{(\mathcal{T}-1)})-r\circ F^{*}(\mathcal{X}^{(\mathcal{T})})\|$ is added. Moreover, for each task, the autoencoders of the previous tasks are trained using the corresponding feature extractors. The remaining difference between the two losses that is neither directly controlled nor decreasing while training the model can be expressed as follows (for a constant $K$):

[TABLE]

where $F^{(*,t)}$ is the feature extraction operator after training the model on the task $t$ data. As observed for (17), expressions (20) and (22) remain small and the conclusion of the experiment in Sec. A.2 holds also for these distances. Therefore, their effect on the growth of the difference with joint-training is minimal. In contrast to the other terms, as for (19), controlling (21) may prevent the network from converging for the new task. Thus, relaxing these distances is an important degree of freedom for our method.

Appendix B Additional experiments

The experiments in this section aim to show that the success of the proposed method is independent of the chosen model. For this purpose, we train VGG-verydeep-16 [26] in a two-task image classification scenario and compare our method against the state-of-the-art (LwF) [13].

Tested scenario

We test our method and LwF on a two-task scenario starting from ImageNet (LSVRC 2012 subset) [22] (more than 1 million training images) then training on MIT Scenes [19] for indoor scene classification (5,360 samples). The showed results are obtained on the test data of Scenes and the validation data of ImageNet.

Architecture

We experiment with VGG-verydeep-16 [26] due to its popularity and success in many image classification tasks. The feature extraction block $F$ corresponds to the convolutional layers. Note that this architecture has feature extractor twice as deep as AlexNet [12] (used in the main text). As for the experiments conducted using AlexNet, the shared task operator $T$ corresponds to all but the last fully connected layers (i.e., $fc6$ and $fc7$), while the task-specific part $T_{i}$ contains the last classification layer ($fc8$). The used hyperparameters are the same as in the main text: same $\alpha$ ($10^{-3}$) for the training of our method, and same $\lambda$ ($10^{-6}$) for the autoencoder training. The used architecture for the autoencoder is also similar to the main text (2-layers with a sigmoid non-linearity in between) with a code of 300 entries. Figure 6 shows the evolution of the code error and the classification error during the training of the autoencoder on ImageNet features extracted using VGG-verydeep-16.

Autoencoder size

To illustrate the growth of the size of the autoencoder with the size of the model, we show in Table 7 the memory required by AlexNet and VGG-verydeep-16 while training for Scenes after ImageNet, along with the autoencoder input length (Feature size) and the memory required by the autoencoder during training with our method. Naturally, the autoencoder size grows with the feature length, but remains very small comparing with the size of the global model.

Results: Method behavior comparison

Figure 7 shows the evolution of the model performance for both tasks, ImageNet and Scenes, when trained with our method (red curves) and with LwF (blue curves).

Our method shows a better preservation of the performance on ImageNet. Even if the classification error grows for both methods, it increases slower in our case. After 20 epochs, the performance on ImageNet is 1% higher using our method.

The test and train errors on Scenes highlight an interesting characteristic of our method. The use of the code loss on top of LwF appears to act as a regularizer for the training on Scenes. Our method shows a slightly higher training error, and a better generalization. VGG-verydeep-16 is a large model, and the risk of overfitting while training on a small dataset like Scenes is higher than for AlexNet. A stronger regularization (using a higher value of $\alpha$) may thus result in an improvement of the behavior of our method.

Conclusion

From this experiment, we observe that the convergence of the autoencoder training and the improvement observed over LwF are not dependent on the used architecture. Moreover, the additional memory required by our method remains small with respect to the size of the global model.