PaperlayerView exact revision on arXiv

Source-linked AI summary

Adversarial Continual Learning

Sayna Ebrahimi, Franziska Meier, Roberto Calandra, Trevor Darrell, Marcus Rohrbach

arXiv:2003.09553v2cs.LGcs.AIcs.CVstat.ML

TL;DR

Continual learning must acquire new tasks while retaining performance on prior ones, motivating representations that distinguish shared structure from task-specific information. ACL factorizes these components and applies architecture growth to private features with replay for shared features. It reports effective forgetting prevention and superiority to architecture-based and memory-based approaches across single-dataset and multi-dataset image-classification settings.

  • Problem

    Continual learning seeks to learn sequential tasks while maintaining performance on all prior tasks, despite catastrophic forgetting from changing representations.

  • Method

    ACL learns disjoint task-invariant and task-specific latent spaces, preserving private modules through architecture growth and shared features through limited experience replay.

  • Results

    ACL achieves state-of-the-art results across visual continual-learning benchmarks, including single-dataset and five-dataset sequential image-classification settings.

  • Takeaways & Limitations

    Shared features are less prone to forgetting, while factorization lets ACL handle shared and task-specific knowledge with different forgetting-prevention mechanisms.

Abstract

from arXiv · show

Continual learning aims to learn new tasks without forgetting previously learned ones. We hypothesize that representations learned to solve each task in a sequence have a shared structure while containing some task-specific properties. We show that shared features are significantly less prone to forgetting and propose a novel hybrid continual learning framework that learns a disjoint representation for task-invariant and task-specific features required to solve a sequence of tasks. Our model combines architecture growth to prevent forgetting of task-specific skills and an experience replay approach to preserve shared skills. We demonstrate our hybrid approach is effective in avoiding forgetting and show it is superior to both architecture-based and memory-based approaches on class incrementally learning of a single dataset as well as a sequence of multiple datasets in image classification. Our code is available at \url{https://github.com/facebookresearch/Adversarial-Continual-Learning}.

1 Introduction

Continual learning methods balance preserving prior skills with learning new tasks, but fixed-capacity, structure-based, and replay-based approaches each face limitations. ACL factorizes shared and task-specific representations, combining architecture growth with limited replay to reduce forgetting and achieve strong visual continual-learning results.

  • Introduction: Fixed-capacity methods control changes to important parameters, whereas structure-based methods grow the network and may require substantial memory for many tasks.These approaches represent distinct strategies for mitigating catastrophic forgetting.
  • Introduction: ACL separates task-invariant shared features from task-specific private features in a disjoint latent representation.Adversarial learning encourages shared features to be task-invariant, while orthogonality constraints separate them from private features.
  • Introduction: Private modules are stored and frozen for each task, while the shared module uses limited experience replay because it is less prone to forgetting.This hybrid design preserves task-specific skills through architecture growth and shared skills through replay.
  • Introduction: ACL achieves state-of-the-art results on MNIST, CIFAR100, Permuted MNIST, miniImageNet, and a sequence of five tasks.The reported evaluations cover both single-dataset class-incremental learning and multiple-dataset sequences.
  • Introduction: Memory-based methods rehearse stored raw samples or generated experiences, while ACL uses a tiny replay buffer specifically with its shared representation and discriminator.ACL differs from prior memory-based methods in how stored examples are applied to shared features.

3 Adversarial Continual learning (ACL)

ACL factorizes each task representation into shared and private latent spaces, then uses adversarial training, orthogonality constraints, architecture growth, and replay to limit forgetting.

  • ACL models each task with a shared latent space for task-invariant features and a private latent space for task-specific features.
  • The shared mapping is trained adversarially so a discriminator cannot predict task labels from its features.The discriminator predicts task labels, while the shared mapping confuses it through gradient reversal.
  • Orthogonality constraints prevent shared features from appearing in private encoded features.The paper also calls this objective a difference loss in domain adaptation literature.
  • Final task predictions use a task-specific multilayer perceptron receiving the concatenation of private and shared features.
  • Private modules are frozen and expanded after each task, while the shared space uses replay to compensate for imperfect factorization.Replay is especially useful when tasks have little overlap or substantial domain shift.
  • ACL evaluates sequential learning by average classification accuracy and backward transfer, where negative backward transfer indicates catastrophic forgetting.The resulting model is evaluated on all prior tasks after each new task is learned.

4 Experiments

The experiments evaluate ACL on standard class-incremental image-classification benchmarks and a sequence of multiple datasets, using established baselines and specified implementation settings.

  • Datasets: The evaluation covers T-split class-incremental benchmarks, including 5-Split MNIST, Permuted MNIST, 20-Split CIFAR100, and 20-Split miniImageNet.The experiments also include a 5-Datasets sequence containing SVHN and CIFAR10, among other datasets.
  • Implementation details: No data augmentation is used in the analysis.
  • Baselines: The study compares ACL with EWC, Progressive Neural Networks, HAT, A-GEM, GEM, and ER-RES.The listed baselines represent prior approaches across the categories reviewed in Section 2.
  • Implementation details: Most ACL experiments use a reduced AlexNet backbone for the S and P modules to support fair comparison with the majority of baselines.Permuted MNIST and 5-Split MNIST are exceptions to this backbone setting.
  • Implementation details: The reported experiments use AlexNet throughout, although the ACL implementation also supports a reduced ResNet18 backbone.The paper states that results with the reduced ResNet18 are not reported in this work.

5 Results and Discussion

ACL combines private-module growth, shared-module replay, and adversarial factorization to reduce forgetting on 20-Split miniImageNet. Experiments and ablations show strong accuracy, near-zero backward transfer, efficient memory use, and distinct shared/private latent spaces.

  • 5.1 ACL Performance on 20-Split miniImageNet: ACL reaches ACC=62.07 ± 0.51 and BWT=0.00 ± 0.00% using 121.6MB total memory on 20-Split miniImageNet.This uses architecture growth plus one replay sample per class, outperforming the listed baselines in the reported comparison.
  • 5.2 Ablation Studies on 20-Split miniImageNet: The ablation study evaluates private and shared modules, discriminator, orthogonality constraint, and one-sample-per-class replay memory using ACC and BWT.Table 1 reports continual-learning results and cumulative ACL ablations, with results averaged over three runs.
  • 5.2 Ablation Studies on 20-Split miniImageNet: Adversarial training improves ACC from 50.15 ± 1.41 to 55.72 ± 1.42% and BWT from -14.32 ± 2.34 to -0.12 ± 0.34%.With replay, the discriminator reaches ACC=60.28 ± 0.52, while the orthogonality loss reaches ACC=52.07 ± 2.49.
  • 5.2 Ablation Studies on 20-Split miniImageNet: Adding the smallest replay buffer improves ACL’s ACC and BWT by 4.41% and 3.71%, respectively, while larger buffers leave ACL’s ACC nearly unchanged.The buffer stores one sample per class for each task, and the comparison includes A-GEM and ER-RES.
  • 5.3 Visualizing the effect of adversarial learning in ACL: Adversarial loss produces uniformly mixed shared latent features across task #20 and the first 10 tasks, unlike the non-uniform features without a discriminator.Private modules trained with the discriminator nearly uncover class and task labels, whereas the no-discriminator private representations are entangled.

6 ACL Performance on a sequence of 5-Datasets

ACL is evaluated on continual learning across five diverse datasets. It outperforms UCB with near-zero backward transfer, using half the memory and no replay buffer.

  • 6 ACL Performance on a sequence of 5-Datasets: ACL reaches ACC=78.55(±0.29) and BWT=-0.01 on a sequence of five datasets, outperforming UCB with half the memory and no replay buffer.Results are averaged over five random task permutations with standard deviations reported for ACC.

7 Additional Experiments

Additional experiments evaluate continual learning on 20-Split CIFAR100, sequences of 5 datasets, and increasing numbers of MNIST tasks, measuring accuracy, backward transfer, and memory.

  • 20-Split CIFAR100: 20-Split CIFAR100 incrementally learns 5 classes at a time across 20 tasks, with ACC, BWT, and memory reported for competing methods.The results average three runs with standard deviations; zero BWT denotes guaranteed zero forgetting.
  • Architecture and Memory: ACL uses memory to add compact private modules and transfers knowledge through a shared module rather than storing old samples for replay.This design is contrasted with memory-based methods that store samples and architecture-based methods that grow an entire network column.
  • 5-Split MNIST: On sequences of 10 and 20 MNIST tasks, ACL achieves ACC=98.03 ± 0.01 and ACC=97.81±0.03, respectively, with BWT=-0.01% and BWT=0%.Performance drops only by 0.2% as the number of tasks doubles, while adding 55K parameters per task uses 2.4MB and 5.0MB overall.

8 Conclusion

The conclusion presents ACL as a hybrid method that separates task-specific and task-invariant features to reduce forgetting while using compact private modules.

  • Conclusion: ACL factorizes task representations into task-specific and task-invariant features, preserving the former fully while finding the latter less prone to forgetting.The method combines adversarial learning with orthogonality constraints to disentangle shared and private latent representations.
  • Conclusion: Compact private modules can be stored in memory to prevent forgetting efficiently, while a tiny replay buffer can be added if forgetting occurs in the shared module.The replay buffer is described as optional rather than critical.
  • Conclusion: ACL establishes a new state of the art on continual-learning benchmark datasets.

(Supplementary Materials)

The supplementary materials identify the paper’s authors and their affiliations.

  • Authors: The paper lists Sayna Ebrahimi, Franziska Meier, Roberto Calandra, Trevor Darrell, and Marcus Rohrbach as authors.
  • Affiliations: The authors are affiliated with Facebook AI Research in Menlo Park and UC Berkeley EECS in Berkeley.

9 Datasets

The datasets section summarizes dataset names, class and task counts, image sizes, per-task sample counts, and classes per task, with no data augmentation used.

  • Dataset Statistics: Table 4a organizes dataset statistics by dataset name, total classes, number of tasks, image size, per-task training, validation, and test images, and classes per task.
  • Dataset Statistics: The supplementary statistics cover 5-Split MNIST and 5-Datasets, including training, validation, and test samples per task.
  • Experimental Setup: No data augmentation is used for any dataset.
  • 5-Datasets: MNIST, notMNIST, and Fashion MNIST are padded with zeros to 32 × 32 resolution and expanded to three channels in 5-Datasets.

10 Results on Permuted MNIST and 5-Split MNIST

Tables 5 and 6 report continual-learning results for Permuted MNIST and 5-Split MNIST, respectively.

  • Tables 5 and 6 measure ACC, BWT, and Memory for Permuted MNIST and 5-Split MNIST experiments.

11 Effect of memory size on ACL

The memory-size analysis compares replay-buffer effects across ACL and memory-dependent baselines, while reporting ACL’s ACC and BWT sensitivity to replay memory.

  • Fig. 3 varies replay memory using 1, 3, 5, and 13 images per class.
  • Table 5 reports ACC, BWT, and Memory for Permuted MNIST, with results averaged over 3 runs and standard deviations in parentheses.
  • ACL’s ACC and BWT are reported as insensitive to replay-buffer size.
  • The comparison evaluates ACL against A-GEM and ER-RES on 20-Split miniImageNet.
  • Table 6 reports ACC, BWT, and Memory for class-incremental 5-Split MNIST, with results averaged over 3 runs and standard deviations in parentheses.

12 Intransigence Measure

The paper defines intransigence as the accuracy gap between a reference model trained on all seen datasets and an incremental model trained sequentially. ACL achieves the lowest, always-negative intransigence across the reported benchmark sequences.

  • Intransigence for task k is defined as I_k = a*_k − a_k,k.
  • a*_k is reference-model accuracy after training on all datasets seen through task k, whereas a_k,k is incremental-training accuracy on task k.
  • I_k lies in the interval [−1, 1].
  • ACL has the lowest intransigence value versus HAT and ER-RES across four reported continual-learning experiments.
  • ACL’s intransigence values are always negative, meaning learning preceding tasks increases the model’s ability to learn later ones.
Loading 2003.09553v2…