EEC: Learning to Encode and Regenerate Images for Continual Learning

An autoencoder is a neural network that is trained to compress and then reconstruct the input (Goodfellow et al., 2016), formally $f_{r}:\mathcal{X}\rightarrow\mathcal{X}$. The network consists of an encoder that compresses the input into a lower dimensional feature space (termed as the encoded episode in this paper), $g_{enc}:\mathcal{X}\rightarrow\mathcal{F}$ and a decoder that reconstructs the input from the feature embedding, $g_{dec}:\mathcal{F}\rightarrow\mathcal{X}$. Formally, for a given input $x\in\mathcal{X}$, the reconstruction pipeline $f_{r}$ is defined as: $f_{r}(x)=(g_{dec}\circ g_{enc})(x)$. The parameters $\theta_{r}$ of the network are usually optimized using an $l_{2}$ loss ($\mathcal{L}_{r}$) between the inputs and the reconstructions:

Although autoencoders are suitable for dimensionality reduction for complex, high-dimensional data like RGB images, the reconstructed images lose the high frequency components necessary for correct classification. To tackle this problem, we train autoencoders using some of the ideas that underline Neural Style Transfer (NST). NST uses a pre-trained CNN to transfer the style of one image to another. The process takes three images, an input image, a content image and a style image and alters the input image such that it has the content image’s content and the artistic style of the style image. The three images are passed through the pre-trained CNN generating convolutional feature maps (usually from the last convolutional layer) and $l_{2}$ distances between the feature maps of the input image and content image (content loss) and style image (style loss) are calculated. These losses are then used to update the input image.

Intuitively, our intent here is to create reconstructed images that are similar to the real images (in the pixel and convolutional space), thereby improving classification accuracy. Hence, we only utilize the idea of content transfer from the NST algorithm, where the input image is the image reconstructed by the autoencoder and content image is the real image corresponding to the reconstructed image. The classifier model, $D$, is used to generate convolutional feature maps for the NST, since it is already trained on real data for the classes in the increment $t$. In contrast to the traditional NST algorithm, we use the content loss ($\mathcal{L}_{cont}$) to train the autoencoder, rather than updating the input image directly. Formally, let $f_{c}:\mathcal{X}\rightarrow\mathcal{F}_{c}$ be the classifier pipeline that converts input images into convolutional features. For an input image, $x_{i}^{t}$ of task $t$, the content loss is:

The autoencoder parameters are optimized using a combination of reconstruction and content losses:

where, $\lambda$ is a hyperparamter that controls the contribution of each loss term towards the complete loss. During autoencoder training, classifier $D$ acts as a fixed feature extractor and its parameters are not updated. This portion of the complete procedure is depicted in Figure 1 (a).

To provide an illustration of our approach, we perform an experiment with ImageNet-50 dataset. We trained one autoencoder on 10 classes from ImageNet-50 with NST and one without NST. Figure 2 depicts the reconstructed images by the two autoencoders. Note that the images generated by the autoencoder trained without using NST are blurry. In contrast, the autoencoder trained using NST creates images with fine-grained details which improves the classification accuracy.

As mentioned in the introduction, continual learning also presents issues associated with the storage of data in memory. For EEC, for each new task $t$, the data is encoded and stored in memory. Even though the encoded episodes require less memory than the real images, the system can still run out of memory when managing a continuous stream of incoming tasks. To cope with this issue, we propose a process inspired by memory integration in the hippocampus and the neocortex (Mack et al., 2018). Memory integration combines a new episode with a previously learned episode summarizing the information in both episodes in a single representation. The original episodes themselves are forgotten.

Consider a system that can store a total of $K$ encoded episodes based on its available memory. Assume that at increment $t-1$, the system has a total of $K_{t-1}$ encoded episodes stored. It is now required to store $K_{t}$ more episodes in increment $t$. The system runs out of memory because $K_{t}+K_{t-1}>K$. Therefore, it must reduce the number of episodes to $K_{r}=K_{t-1}+K_{t}-K$. Because each task is composed of a set of classes at each increment, we reduce the total encoded episodes belonging to different classes based on their previous number of encoded episodes. Formally, the reduction in the number of encoded episodes $N_{y}$ for a class $y$ is calculated as (whole number):

To reduce the encoded episodes to $N_{y}(new)$ for class $y$, inspired by the memory integration process, we use an incremental clustering process that combines the closest encoded episodes to produce centroids and covariance matrices. This clustering technique is similar to the Agg-Var clustering proposed in our earlier work (Ayub & Wagner, 2020b; a). The distance between encoded episodes is calculated using the Euclidean distance, and the centroids are calculated using the weighted mean of the encoded episodes. The process is repeated until the sum of the total number of centroids/covariance matrices and the encoded episodes for class $y$ equal $N_{y}(new)$. The original encoded episodes are removed and only the centroid and the covariances are kept (see Appendix A for more details).

Figure 1 (b) depicts the procedure for training the classifier $D$ when new data belonging to task $t$ becomes available. The classifier is trained on data from three sources: 1) the real data for task $t$, 2) reconstructed images generated from the autoencoder’s decoder, and 3) pseudo-images generated from centroids and covariance matrices for previous tasks. Source (2) uses the encodings from the previous tasks to generate a set of reconstructed images by passing them through the autoencoder’s decoder. This process is referred to as rehearsal (Robins, 1995).

Pseudorehearsal: If the system also has old class data stored as centroids/covariance matrix pairs, pseudorehearsal is employed. For each centroid/covariance matrix pair of a class we sample a multivariate Gaussian distribution with mean as the centroid and the covariance matrix to generate a large set of pseudo-encoded episodes. The episodes are then passed through the autoencoder’s decoder to generate pseudo-images for the previous classes. Many of the pseudo-images are noisy. To filter the noisy pseudo-images, we pass them through classifier $D$, which has already been trained on the prior classes, to get predicted labels for each pseudo-image. We only keep those pseudo-images that have the same predicted label as the label of the centroid they originated from. Among the filtered pseudo-images, we select the same number of pseudo-images as the total number of encoded episodes represented by the centroid and discard the rest (see Appendix A for the algorithm).

To illustrate the effect of memory integration and pseudorehearsal, we performed an experiment on MNIST dataset. We trained an autoencoder on 2 classes (11379 images) from MNIST dataset with the embedding dimension of size 2. After training, we passed all the training images for the two classes through the encoder to get 11379 encoded episodes (see Figure 3 (a)). Next, we applied our memory integration technique on the encoded episodes to reduce the encoded episodes to 4000, 2000, 1000 and 200 centroids (and covariances). No original encoded episodes were kept. Pseudorehearsal was then applied on the centroids to generate pseudo-encoded episodes. The pseudo-encoded episodes for different numbers of centroids are shown in Figure 3 (b-e). Note that the feature space for the pseudo-encoded episodes generated by different number of centroids is very similar to the original encoded episodes. For a larger number of centroids, the feature space looks almost exactly the same as the original feature space. For the smallest number of centroids (Figure 3 (e)), the feature space becomes less uniform and more divided into small dense regions. This is because a smaller number of centroids are being used to represent the overall concept of the feature space across different regions resulting in large gaps between the centroids. Hence, the pseudo-encoded episodes generated using the centroids are more dense around the centroids reducing uniformity. Still, the overall shape of the feature space is preserved after using the centroids and pseudorehearsal. Hence, our approach conserves information about previous classes, even with less memory, contributing to classifier performance while also avoiding catastrophic forgetting. The results presented in Section 4.3 on ImageNet-50 confirm the effectiveness of memory integration and pseudorehearsal.

Sample Decay Weight: The reconstructed images and pseudo-images can still be quite different from the original images, hurting classifier performance. We therefore weigh the loss term for reconstructed and pseudo-images while training $D$. For this, we estimate the degradation in the reconstructed and pseudo-images. To estimate degradation in the reconstructed images, we find the ratio of the classification accuracy of the reconstructed images ($c^{r}$) to the accuracy of the original images ($c^{o}$) on network $D$ trained on previous tasks. This ratio is used to control the weight of the loss term for the reconstructed images. For a previous task $t-1$, the weight $\Gamma_{t-1}^{r}$ (the sample decay weight) for the loss term $\mathcal{L}_{t-1}^{r}$ of the reconstructed images is defined as:

where $\gamma^{r}_{t-1}=1-\frac{c^{r}_{t-1}}{c^{o}_{t-1}}$ (sample decay coefficient) denotes the degradation in reconstructed images of task $t-1$ and $\alpha_{t-1}$ represents the number of times an autoencoder has been trained on the pseudo-images or reconstructed images of task $t-1$. The value of sample decay coefficient ranges from 0 to 1, depending on the classification accuracy of the reconstructed images $c^{r}_{t-1}$. If $c^{r}_{t-1}=c^{o}_{t-1}$, $\gamma^{r}_{t-1}=0$ (no degradation) and $\Gamma_{t-1}^{r}=1$. Similarly, the sample decay weight $\Gamma^{p}_{t-1}$ for loss term $\mathcal{L}_{t-1}^{p}$ for the pseudo-images is based on the classification accuracy $c^{p}_{t-1}$ of pseudo-images for task $t-1$. Thus, for a new increment, the total loss $\mathcal{L}_{D}$ for training $D$ on the reconstructed and pseudo-images of the old tasks and real images of the new task $t$ is defined as:

The MNIST dataset consists of grey-scale images of handwritten digits between 0 to 9, with 50,000 training images, 10,000 validation images and 10,000 test images. SVHN consists of colored cropped images of street house numbers with different illuminations and viewpoints. It contains 73,257 training and 26,032 test images belonging to 10 classes. CIFAR-10 consists of 50,000 RGB training images and 10,000 test images belonging to 10 object classes. Each class contains 5000 training and 1000 test images. ImageNet-50 is a smaller subset of the iLSVRC-2012 dataset containing 50 classes with 1300 training images and 50 validation images per class. All of the dataset images were resized to 32$\times$32, in concordance to (Ostapenko et al., 2019).

We used Pytorch (Paszke et al., 2019) and an Nvidia Titan RTX GPU for implementation and training of all neural network models. A 3-layer shallow convolutional autoencoder was used for all datasets (see Appendix B), which requires approximately 0.2MB of disk space for storage. For classification, on the MNIST and SVHN datasets the same classifier as the DCGAN discriminator (Radford et al., 2015) was used, for CIFAR-10 the ResNet architecture proposed by Gulrajani et al. (2017) was used and for ImageNet-50, ResNet-18 (He et al., 2016) was used.

In concordance with Ostapenko et al. (2019) (DGMw), we report the average incremental accuracy on 5 and 10 classes ($A_{5}$ and $A_{10}$) for the MNIST, SVHN and CIFAR-10 datasets trained continually with one class per increment. For ImageNet-50, the average incremental accuracy on 3 and 5 increments ($A_{30}$ and $A_{50}$) is reported with 10 classes in each increment. For a fair comparison, we typically compare against approaches with a generative memory replay component that do not use a pre-trained feature extractor and are evaluated in a single-headed fashion. Among such approaches, to the best of our knowledge, DGMw represents the state-of-the-art benchmark on these datasets which is followed by MeRGAN (Wu et al., 2018a), DGR (Shin et al., 2017) and EWC-M (Seff et al., 2017). Joint training (JT) is used to produce an upperbound for all four datasets. We compare these methods against two variants of our approach: EEC and EECS. EEC uses a separate autoencoder for classes in a new increment, while EECS uses a single autoencoder that is retrained on the reconstructed images of the old classes when learning new classes. For both EEC and EECS, results are reported when all of the encoded episodes for the previous classes are stored. The results for EEC under restricted memory conditions are also presented.

Hyperparameter values and training details are reported in Appendix C. We performed each experiment 10 times with different random seeds and report average accuracy over all runs.

Table 1 compares EEC and EECS against SOTA approaches on the MNIST, SVHN, CIFAR-10 and ImageNet-50 datasets. We compare against two different types of approaches, those that use real images (episodic memory) of the old classes and those that generate previous class images when learning new classes. Both EEC and EECS outperform EWC-M and DGR by significant margins on the MNIST on $A_{5}$ and $A_{10}$. MeRGAN and DGMw perform similarly to our methods on the $A_{5}$ and $A_{10}$ experiments. Note that MeRGAN and EEC approach the JT upperbound on $A_{5}$. Further, accuracy for MeRGAN, DGMw and EEC changes only slightly between $A_{5}$ and $A_{10}$, suggesting that MNIST is too simple of a dataset for testing continual learning using generative replay.

Considering SVHN, a more complex dataset consisting of colored images of street house numbers, the performance of our method remains reasonably close to the JT upperbound, even though the performance of other approaches decreases significantly. For $A_{5}$, EEC achieves only 0.27% lower accuracy than JT and 11.36% higher than DGMw (current best method). For $A_{10}$, EEC is 4.55% lower than JT but still 15.21% higher than DGMw and achieves 5.66% higher accuracy on $A_{10}$ than DGMw did on $A_{5}$. EECS performs slightly lower than EEC on $A_{5}$ but the gap widens on $A_{10}$. However, EECS also beats the SOTA approaches on both $A_{5}$ and $A_{10}$.

Considering the more complex CIFAR-10 and ImageNet-50 datasets, only DGMw reported results for these datasets. On CIFAR-10, EEC beats DGMw on $A_{5}$ by a margin of 20.18% and on $A_{10}$ by a margin of 10.7%. Similar to the SVHN results, the accuracy achieved by EEC on $A_{10}$ is even higher than DGMw’s accuracy on $A_{5}$. In comparison with the JT, EEC performs similarly on $A_{5}$ (0.38% lower), however on $A_{10}$ it performs significantly lower. For ImageNet-50, again we see similar results as both EEC and EECS outperform DGMw on $A_{30}$ and $A_{50}$ by significant margins (13.29% and 17.42%, respectively). Similar to SVHN and CIFAR-10 results, accuracy for EEC on $A_{50}$ is even higher than DGMw’s accuracy on $A_{30}$. Further, EEC also beats iCaRL (episodic memory SOTA method) with margins of 16.01% and 6.26% on $A_{30}$ and $A_{50}$, respectively, even though iCaRL has an unfair advantage of using stored real images.

Discussion: Our method performed consistently across all four datasets, especially on $A_{5}$ for MNIST, SVHN and CIFAR-10. In contrast, DGMw (the best current method) shows significantly different results across the four datasets. The results suggest that the current generative memory-based SOTA approaches are unable to mitigate catastrophic forgetting on more complex RGB datasets. This could be because GANs tend to generate images that do not belong to any of learned classes, which can drastically reduce classifier performance. Our approach copes with these issues by training autoencoders borrowing ideas from the NST algorithm and retraining of the classifier with sample decay weights. Images reconstructed by EEC for MNIST and CIFAR-10 after 10 tasks and for ImageNet-50 after 5 tasks are shown in Figure 4.

Memory Usage Analysis: Similar to DGMw, we analyze the disc space required by our model for the ImageNet-50 dataset. For EEC, the autoencoders use a total disc space of 1 MB, ResNet-18 uses about 44 MB, while the encoded episodes use a total of about 66.56 MB. Hence, the total disc space required by EEC is about 111.56 MB. DGMw’s generator (with corresponding weight masks), however, uses 228MB of disc space and storing pre-processed real images of ImageNet-50 requires disc space of 315MB. Hence, our model requires 51.07% ((228-111.56)/228 = 0.5107) less space than DGMw and 64.58% less space than the real images for ImageNet-50 dataset.

EEC was tested with different memory budgets on the ImageNet-50 dataset to evaluate the impact of our memory management technique. The memory budgets (K) are defined as the sum of the total number of encoded episodes, centroids and covariance matrices (diagonal entries) stored by the system. Figure 6 shows the results in terms of $A_{30}$ and $A_{50}$ for a wide range of memory budgets. The accuracy of EEC changes only slightly over different memory budgets. Even with a low budget of K=5000, the $A_{30}$ and $A_{50}$ accuracies are only 3.1% and 3.73% lower than the accuracy of EEC with unlimited memory. Further, even for K=5000, EEC beats DGMw (current SOTA on ImageNet-50) by margins of 10.17% and 13.73% on $A_{30}$ and $A_{50}$, respectively. The total disc space required for K=5000 is only 5.12 MB and the total disc space for the complete system is 50.12 MB (44 MB for ResNet-18 and 1 MB for autoencoders), which is 78.01% less than DGMw’s required disc space (228 MB). These results clearly depict that our approach produces the best results even with extremely limited memory, a trait that is not shared by other SOTA approaches. Moreover, the results also show that our approach is capable of dealing with the two main challenges of continual learning mentioned earlier: catastrophic forgetting and memory management.

We performed an ablation study to examine the contribution of using: 1) the content loss while training the autoencoders, 2) pseudo-rehearsal and 3) the sample weight decay. These experiments were performed on the ImageNet-50 dataset. Complete encoded episodes of previous tasks were used for ablations 1 and 3, and a memory budget of K=5000 was used for ablation 2. We created hybrid versions of EEC to test the contribution of each component. Hybrid 1: termed as EEC-noNST does not use the content loss while training the autoencoders. Hybrid 2: termed as EEC-CGAN uses a conditional GAN instead of NST based autoencoder. Hybrid 3: termed as EEC-VAE uses a variational autoencoder and Hybrid 4: termed as EEC-DNA uses a denoising autoencoder instead of our proposed NST based autonecoder. Hybrid 5: termed as EEC-noPseudo simply removes the extra encoded episodes when the system runs out of memory and does not use pseudo-rehearsal. Hybrid 6: termed as EEC-noDecay does not use sample weight decay during classifier training on new and old tasks. Except for the changed component, all the other components in the hybrid approaches were the same as used in EEC.

All of the hybrids show inferior performance as compared to the complete EEC approach (Table 6). Evaluated on $A_{30}$ and $A_{50}$, EEC-noNST, EEC-CGAN, EEC-VAE and EEC-DNA all result in $\sim$5.8% and $\sim$6.5% lower accuracy, respectively than EEC. EEC-noDecay results in 3.77% and 4.77% lower accuracy on $A_{30}$ and $A_{50}$ respectively, than EEC. As a fair comparison with EEC using K=5000, EEC-noPseudo results in 4.98% and 6.27% lower accuracy for $A_{30}$ and $A_{50}$, respectively. The results show that all of these components contribute significantly to the overall performance of EEC, however training the autoencoders with content loss and pseudo-rehearsal seem to be more important. Also, note that the conditional GAN with the other components of our approach (such as sample weight decay) produces 7.80% and 11.3% higher accuracy on $A_{30}$ and $A_{50}$, respectively, than DGMw. Further note that all the hybrids that do not use the NST based autoencoder (Hybrids 1-4) produce similar accuracy, since they use the sample weight decay to help mange the degradation of reconstructed images. These results show the effectiveness of sample weight decay to cope with image degradation.

As mentioned in Subsection 4.2, all the experiments on the four datasets were done using resized images of size 32$\times$32. To show further insight into our approach, we performed experiments on ImageNet-50 dataset with higher resolution images of size 256$\times$256 and randomly cropped to 224$\times$224. Evaluated on $A_{30}$ and $A_{50}$, EEC achieved 70.75% and 56.89% accuracy, respectively using images of size 224$\times$224. These results show that using higher resolution images improve the performance of EEC by significant margins (25.36% and 21.65% increase on $A_{30}$ and $A_{50}$). Note that storing real high resolution images requires a much larger disk space than storing images of size 32$\times$32. For ImageNet-50, storing original images of size 224$\times$224 requires 39.13GB, while images of size 32$\times$32 require only 315MB. In contrast, EEC requires only 13.04 GB (66% less than real images of size 224$\times$224) when using the same autoencoder architecture that was used for images of size 32$\times$32. Using a different architecture, we can bring the size of encoded episodes to be the same as for images of size 32$\times$32 but the accuracy achieved is lower. These results further show the effectiveness of our approach to mitigate catastrophic forgetting while using significantly less memory compared to real images.