Avalanche

Avalanche provides a unified API for generating and managing continual learning scenarios from standard datasets like MNIST, CIFAR, and COCO. Core abstractions include:

• CLScenario: Defines the sequence of tasks or experiences.
• CLStream: A iterable stream of CLExperience objects, representing data for a specific phase (e.g., train_stream, test_stream).
• CLExperience: A single chunk of data, which could be a task, a class batch, or a temporal slice.

This modular design cleanly separates the data generation logic from the learning algorithm, enabling reproducible benchmarking on scenarios like Class-Incremental Learning (Class-IL), Task-Incremental Learning (Task-IL), and Domain-Incremental Learning.

The library's engine is built around configurable, extensible loops that manage the training and evaluation lifecycle. The Strategy class is the central controller, encapsulating a specific continual learning algorithm (e.g., EWC, GEM, Experience Replay).

Key loop components:

• TrainingLoop: Iterates over the data stream, calls the strategy's train_exp method, and manages callbacks.
• EvaluationLoop: Handles periodic and final evaluation on test streams.
• BaseStrategy: The parent class for all algorithms, defining the template methods (train_exp, eval_exp) that users override or plugins extend.

This loop-based architecture standardizes the experimental workflow, ensuring consistent metric logging and plugin execution across different algorithms.

Avalanche implements a comprehensive suite of continual learning strategies as subclasses of BaseStrategy. These are pre-built, ready-to-use algorithms organized by their mitigation category:

• Regularization-based: EWCStrategy, LwFStrategy, SynapticIntelligenceStrategy.
• Replay-based: ReplayStrategy, GEMStrategy**, DERStrategy`.
• Architectural: Naive (the baseline that forgets), with support for custom dynamic architectures.
• Hybrid: AR1Strategy, iCaRLStrategy.

Each strategy cleanly integrates with the loop system and logging plugins. Users can also implement custom strategies by extending BaseStrategy and overriding a few key methods, promoting rapid prototyping and fair comparison.

Avalanche offers utilities and base classes for defining continual learning models. It is framework-agnostic but provides deep integration with PyTorch. Key features include:

• AvalancheModule: A wrapper for torch.nn.Module that adds features like automatic task labels and support for multi-head classifiers.
• Dynamic Architectures: Support for progressive networks and parameter isolation methods (e.g., HAT) through flexible model definitions and masking utilities.
• Multi-Task Heads: Built-in patterns for attaching task-specific output layers, which is crucial for Task-Incremental Learning scenarios.

This component ensures models are properly instrumented to interact with Avalanche's training loops and logging systems.

A comprehensive, real-time evaluation system is central to Avalanche. It automatically computes a wide array of continual learning metrics during and after training.

Core metrics include:

• Accuracy Matrix: Tracks accuracy per task after learning each subsequent task.
• Backward Transfer (BWT): Measures the influence of new learning on old tasks.
• Forward Transfer (FWT): Measures the influence of prior learning on new tasks.
• RAM/CPU Usage: Tracks computational resources.

Metrics are managed by Metric objects and aggregated by PluginMetric instances. Results can be logged to stdout, TensorBoard, Weights & Biases, or custom backends via a flexible plugin system, enabling deep experimental analysis.

Avalanche is designed for maximum extensibility through a plugin system. Plugins can hook into the training/evaluation loops to modify behavior, collect data, or implement algorithm components without altering core code.

Common plugin examples:

• Early Stopping: Halts training based on validation metrics.
• Model Checkpointing: Saves model snapshots.
• Replay Buffer Managers: Implement complex sampling strategies for Experience Replay.
• Evaluation Schedulers: Controls when evaluation runs.

This architecture makes Avalanche not just a collection of algorithms, but a platform for developing new continual learning research, where novel components can be injected seamlessly into the standardized pipeline.

Avalanche supports scenarios where pre-trained models must be continuously adapted in deployment to handle concept drift or new tasks with minimal downtime.

• Incremental Updates: Models can be updated online or in mini-batch increments as new data arrives, simulating real-world data streams.
• Memory-Constrained Learning: Algorithms are designed and evaluated with fixed memory budgets, mirroring production constraints.
• Compatibility: Trained Avalanche models are standard PyTorch modules, allowing for easy export and integration into existing ML serving platforms like TorchServe or Triton Inference Server.

The overarching machine learning paradigm where a model learns sequentially from a stream of non-stationary data or tasks, aiming to accumulate knowledge over time. This is the core problem domain for which Avalanche provides a unified framework. Key challenges include:

• Catastrophic Forgetting: The primary issue of losing performance on old tasks.
• Forward/Backward Transfer: Measuring how new learning affects future or past task performance.
• Stability-Plasticity Dilemma: Balancing retention of old knowledge with adaptation to new information.

The tendency of a neural network to abruptly and drastically lose previously learned information when trained on new, non-i.i.d. data. This is the fundamental problem Avalanche libraries are designed to mitigate. It occurs due to parameter interference, where gradient updates for a new task overwrite weights critical for old tasks. Mitigation strategies implemented in Avalanche include regularization, replay, and architectural methods.

A foundational replay-based method where a subset of past training examples is stored in a fixed-size memory buffer. During training on new tasks, these stored exemplars are interleaved with new data, approximately maintaining the i.i.d. data assumption. Avalanche provides built-in support for ER and its variants (e.g., Dark Experience Replay). Key design choices include:

• Buffer sampling strategy (e.g., reservoir sampling).
• Buffer management policy for which examples to retain.
• Rehearsal ratio for mixing old and new data.

A seminal regularization-based continual learning algorithm. EWC adds a quadratic penalty term to the loss function to constrain the movement of parameters deemed important for previous tasks. Importance is estimated via the diagonal of the Fisher Information Matrix. In practice, this means the loss function becomes: L_new(θ) + λ * Σ_i F_i * (θ_i - θ*_i)^2, where F_i is the Fisher importance for parameter i, and θ*_i is its value after the old task. Avalanche includes EWC as a standard plugin strategy.

A replay-based method that stores past examples in an episodic memory and uses them to define constraints on gradient updates. Instead of directly rehearsing on old data, GEM solves a quadratic programming problem to project the current gradient into a region that does not increase the loss on the memory examples. This ensures positive backward transfer or at least avoids negative transfer. Avalanche implements GEM and its more efficient variant, Averaged GEM (A-GEM).

One of the most challenging and realistic scenarios supported by Avalanche for benchmarking. In OCIL, a model must learn new classes from a non-i.i.d. data stream one example or mini-batch at a time, with key constraints:

• No explicit task boundaries during training.
• A strict, fixed memory budget for replay.
• Evaluation on all classes seen so far. This scenario tests a algorithm's ability to learn continuously and efficiently without task identifiers, mirroring real-world data streams.