Source-linked AI summary
Rehearsal-Free Continual Learning over Small Non-I.I.D. Batches
Vincenzo Lomonaco, Davide Maltoni, Lorenzo Pellegrini
TL;DR
Robotic vision requires continual learning that adapts to new classes and instances from short, highly correlated video streams without forgetting. The paper introduces a CORe50 NIC protocol and rehearsal-free CWR* and AR1* methods, alongside Batch Renormalization for small batches. CWR* and AR1* learn across long sequences of small batches, although AR1* remains more than 20% below cumulative training accuracy.
Problem
Robotic object recognition requires learning new classes and instances from short videos, but very small non-i.i.d. batches make gradient-based continual learning and rehearsal-free updates difficult.
Method
The paper introduces a CORe50-based NIC protocol and rehearsal-free CWR* and AR1* strategies, using Batch Renormalization to support continual learning over small batches.
Results
CWR* and AR1* learn effectively across long sequences of small, highly correlated batches, while AR1* reaches 55–65% final accuracy depending on batch granularity.
Takeaways & Limitations
Rehearsal-free continual learning is feasible for one-class-at-a-time streams, with CWR* and AR1* outperforming the evaluated EWC, LWF, and DSLDA approaches in accuracy and efficiency.
Takeaways & Limitations
AR1* remains more than 20% below cumulative training accuracy of approximately 85%, motivating future work on pseudorehearsal and edge deployment.
Abstract
from arXiv · showhide
Robotic vision is a field where continual learning can play a significant role. An embodied agent operating in a complex environment subject to frequent and unpredictable changes is required to learn and adapt continuously. In the context of object recognition, for example, a robot should be able to learn (without forgetting) objects of never before seen classes as well as improving its recognition capabilities as new instances of already known classes are discovered. Ideally, continual learning should be triggered by the availability of short videos of single objects and performed on-line on on-board hardware with fine-grained updates. In this paper, we introduce a novel continual learning protocol based on the CORe50 benchmark and propose two rehearsal-free continual learning techniques, CWR* and AR1*, that can learn effectively even in the challenging case of nearly 400 small non-i.i.d. incremental batches. In particular, our experiments show that AR1* can outperform other state-of-the-art rehearsal-free techniques by more than 15% accuracy in some cases, with a very light and constant computational and memory overhead across training batches.
1. Introduction
Continual learning must preserve prior knowledge while adapting to new classes and instances from small, non-i.i.d. streams, a setting especially relevant to robotic vision. This paper addresses that challenge with rehearsal-free methods, a new CORe50 NIC protocol, and normalization and efficiency modifications.
- Motivation: Small, non-i.i.d. batches containing new classes and instances make continual learning particularly challenging for robotic object recognition.The NIC setting includes known and previously unseen classes, while robot videos yield highly correlated frames from single objects.
- Methods: CWR* and AR1* extend rehearsal-free continual learning to batches whose composition is not fixed, supporting both NC and NIC updates.CWR* reloads consolidated weights for known classes and uses weighted consolidation, while AR1* extends end-to-end continual training.
- Normalization: Replacing Batch Normalization with Batch Renormalization enables SGD to continually learn from very small, non-i.i.d. batches.Batch Renormalization reduces instability from unreliable mini-batch moments by incorporating global statistics.
- Efficiency: The paper also proposes depthwise layer freezing and learning-rate-based weight constraining to reduce storage and computation without hindering accuracy.These approaches target the efficiency overhead of existing continual learning techniques.
- Protocol: The paper introduces a CORe50-based NIC protocol with 79, 196, and 391 training batches to evaluate long sequences of small updates.The protocol targets real-world, highly correlated images and explicitly addresses non-i.i.d. continual learning.
2. Continual Learning Strategies
The paper adapts rehearsal-free continual learning to NIC batches by modifying CWR+, stabilizing normalization with Batch Renormalization, selectively freezing layers, and reducing weight-update overhead. CWR* and AR1* are evaluated under increasingly fine-grained continual updates, with AR1* showing unexpected efficacy after standard approaches struggle.
- 2.3. Selective Weight Freeze: Depthwise-layer freezing offers a selective computation and storage reduction for depthwise-separable CNNs, although its accuracy impact is scenario-dependent.The NI experiment compares tuning all weights with freezing depthwise, pointwise, or all convolutional layers across eight batches.
- 2.1. From CWR+ to CWR*: CWR+ maintains consolidated inference weights and temporary training weights, resetting temporary weights before each batch while iteratively updating the consolidated set.The CWR* modification preserves this two-memory structure while changing how known-class weights are reloaded and consolidated.
- 2.1. From CWR+ to CWR*: CWR* extends CWR+ to NIC by reloading consolidated weights for known classes and combining past and current contributions with weighted consolidation.A square-root adjustment prevents the past-weight term from suppressing learning when many small batches arrive.
- 2.2. Replacing Batch Normalization with Batch Renormalization: Batch Renormalization replaces unstable minibatch statistics with constrained corrections based partly on moving-average global statistics for small, non-i.i.d. batches.When its correction parameters equal r = 1 and d = 0, Batch Renormalization is equivalent to Batch Normalization; clipping moves it toward global-statistics normalization.
- 2.4. Weight Constraining by Learning Rate Modulation: AR1-style weight constraining reduces each parameter’s learning rate according to its past importance, reaching complete freezing for weights at the clipped maximum importance.This alternative avoids calibrating λ and storing a second copy of all model weights, while producing results similar to the original update in AR1 experiments.
3. CORe50 NICv2
CORe50 NICv2 extends continual object-recognition evaluation with more balanced class introductions and progressively smaller batches, reaching 391 single-session, single-class updates.
- Dataset: CORe50 contains 164,866 128×128 images of 50 domestic objects across 10 categories and 11 video sessions per object.Sessions capture lighting, background, pose, and occlusion variation; labels support supervised classification.
- Limitations of NIC: The original NIC protocol introduced most classes early, making its sequence close to a New Instances scenario.Its first batch contained 10 classes, followed by 78 batches of about 1,500 images from 5 classes.
- NICv2 protocol: NICv2 balances first class introductions across batches and progressively reduces batch size to create finer-grained continual updates.The protocol is designed to better reflect applications where new objects may be discovered later.
- NICv2 protocol: NICv2-391 contains 390 incremental batches, each with one approximately 300-image training session from a single class.The protocol generator assigns sessions across permitted insertion ranges, while experiments use a down-sampled test set for repeated evaluation.
- Evaluation: The NICv2 test set uses three held-out sessions per class with no training intersection, sampled at one frame per second for efficient evaluation.The authors provide protocol file lists and the down-sampled test set online.
4. Experimental Results
Experiments compare rehearsal-free continual-learning methods across increasingly fine-grained NICv2 protocols, emphasizing accuracy, stability, and constant efficiency overhead. CWR* and AR1* remain effective through 391 single-class batches, while Batch Renormalization supports learning in this hardest setting and AR1* offers a strong accuracy–efficiency trade-off.
- Efficiency: Depthwise-layer freezing reduces gradient computation and per-weight auxiliary storage, although it has negligible accuracy impact in NICv2 experiments.The authors found the strategy more advantageous in other scenarios, including New Instances curves.
- Accuracy across NICv2: CWR* and AR1* maintain strong learning trends across NICv2-79, NICv2-196, and NICv2-391, with only minor accuracy loss as batches become smaller.Their curves are stable across 10 runs; Naïve, LWF, and EWC degrade with more batches, while DSLDA remains below both proposed methods.
- Batch normalization: Batch Normalization heavily hurts AR1* on 391 batches, whereas Batch Renormalization enables CWR* and AR1* to learn with single-class updates.Batch Renormalization also provides advantages with larger batches containing patterns from more than one class.
- Efficiency: AR1* achieves the best reported trade-off between accuracy and efficiency, completing a NICv2-391 run in about 40 minutes with 12.4 MB fixed memory overhead.The listed rehearsal-free methods keep constant memory and computational overhead independent of the number of processed batches.
- Weight constraining: Learning-rate modulation improves AR1* accuracy by less than 0.1% on average in NICv2-79 but avoids storing about 3.2 million optimal-weight values.Its main benefit is therefore storage reduction rather than accuracy improvement.
5. Conclusions
CWR* and AR1* learn effectively from long sequences of small, highly correlated batches, but AR1* remains substantially below cumulative-training accuracy. The paper also identifies missing comparisons and future directions for narrowing this gap.
- CWR* and AR1* learned effectively over long sequences of small, highly correlated batches, including one-class-at-a-time training.Both methods showed a near-linear learning trend and robustness to small one-class batches.
- DSLDA performed well, but its accuracy and efficiency were lower than those of CWR* and AR1*.
- The analysis omitted rehearsal-based methods and other approaches, so a more comprehensive comparison remains future work.The authors note that ICARL and GEM were not evaluated here because external memory adds storage and computation costs.
- AR1* reached 55–65% final accuracy depending on batch granularity, versus approximately 85% for cumulative training, leaving a gap greater than 20%.The authors propose pseudorehearsal as a future direction for reducing this gap.
A. Implementation and Experiments Details
Experiments averaged accuracy curves over ten runs with different batch orders and used a single-GPU Ubuntu 16.04 Docker environment. The section reports the NICv2 protocol and implementation setup before presenting strategy details.
- Accuracy curves were averaged over 10 runs, with each run differing in the order of encountered batches.Algorithm 3 provides further details about the NICv2 protocol.
- Experiments ran in an Ubuntu 16.04 Docker environment using a single GPU.Host configuration details are reported in table 3.
- The section introduces the original CWR+ algorithm and the procedure for generating the NICv2 protocol.
A.1. Original CWR+ Strategy
Original CWR+ is suited to new-class learning because each class is encountered once, but overwriting class-specific weights makes it unsuitable for repeated-instance and mixed incremental batches. CWR* fixes this by updating previously learned weights.
- The original CWR+ strategy is provided as pseudocode for completeness in Algorithm 2.
- CWR+ is not well suited to NI and NIC scenarios because successive batches overwrite previous CWR-layer weights.Overwriting is harmless in NC because each class is encountered in exactly one batch and its class-specific weights are initialized only once.
- CWR* addresses the overwriting problem by updating previously learned weights instead of overwriting them.
A.2. NICv2 Protocol Generation
NICv2 distributes the first introduction of classes evenly across training batches, avoiding the original NIC protocol’s early class concentration. This produces more challenging and realistic runs for continual-learning evaluation.
- The original NIC protocol introduces classes mainly in initial batches, making later runs resemble the NI scenario because few new classes appear afterward.Figure 2 shows this concentration of class introductions.
- NICv2 forces class first introductions to be evenly distributed across batches, producing more challenging and realistic runs.
- NICv2 is intended as a theoretical benchmark that avoids assumptions about when and in what order new classes are introduced.
- Algorithm 3 generates NICv2, while Figures 6 and 7 show class distributions for NICv2-196 and NICv2-391 runs.
B. Hyperparameters
The experiments use fixed hyperparameters across three NICv2 scenarios, with AR1* receiving a distinct higher learning rate for its CWR layer and Weight Constraining applied only to AR1*.
- B. Hyperparameters: AR1* uses separate learning rates for the CWR layer and the rest of the network, with a higher CWR-layer rate improving overall performance empirically.The CWR-layer update is inherited from CWR*.
- B. Hyperparameters: Weight Constraining by Learning Rate Modulation is applied only to AR1*, while EWC retains its original behavior for direct comparison.The authors describe this choice as enabling a more direct and unbiased comparison of the proposed strategies.
- B. Hyperparameters: Hyperparameters are selected on run 0, fixed for runs 1–9, and kept identical across NICv2-79, NICv2-196, and NICv2-391.The values follow the notation introduced in [21].
- B. Hyperparameters: NICv2 generation averages ten runs because pattern presentation order affects continual-learning accuracy.Each run begins with one training session from one class in each category, while remaining classes are inserted randomly within permitted positions.
- B. Hyperparameters: NICv2-391 differs from NICv2-79 and NICv2-196 by restricting every batch to patterns from a single class.The protocol represents classes by rows, batches by columns, and colored blocks for class presence.