Overcoming Catastrophic Forgetting in Federated Class-Incremental Learning via Federated Global Twin Generator

## Abstract

Abstract Federated Class-Incremental Learning (FCIL) increasingly becomes important in the decentralized setting, where it enables multiple participants to collaboratively train a global model to perform well on a sequence of tasks without sharing their private data. In FCIL, conventional Federated Learning algorithms such as FedAVG often suffer from catastrophic forgetting, resulting in significant performance declines on earlier tasks. Recent works, based on generative models, produce synthetic images to help mitigate this issue across all classes, but these approaches’ testing accuracy on previous classes is still much lower than recent classes, i.e., having better plasticity than stability. To overcome these issues, this paper presents Federated Global Twin Generator (FedGTG), an FCIL framework that exploits privacy-preserving generative-model training on the global side without accessing client data. Specifically, the server trains a data generator and a feature generator to create two types of information from all seen classes, and then it sends the synthetic data to the client side. The clients then use feature-direction-controlling losses to make the local models retain knowledge and learn new tasks well. We extensively analyze the robustness of FedGTG on natural images, as well as its ability to converge to flat local minima and achieve better-predicting confidence (calibration). Experimental results on CIFAR-10, CIFAR-100, and tiny-ImageNet demonstrate the improvements in accuracy and forgetting measures of FedGTG compared to previous frameworks.

## 1 Introduction

Federated Learning (FL) [, ] is a Machine Learning setting that facilitates collaborative learning while maintaining privacy. Despite its significant achievements on various domains [, , , ], FL observes several critical challenges, including resource limitation and data heterogeneity. Moreover, the client’s local data distribution is assumed to remain unchanged, but the real-world scenarios [] can be totally different, where the client’s task, data, and domain can be changed, as shown in Figure 1. To overcome such challenges, Federated Class-Incremental Learning (FCIL) [, ] is an innovative approach that combines the principles of FL and Class-Incremental Learning (CIL) [] to enable models to learn continuously from decentralized data sources while adapting to new information over time without forgetting previous knowledge  []. This approach addresses data privacy challenges and ensures the model can evolve as new data types or tasks emerge without needing to access historical data. In CIL, exemplar-based approaches [, , ] preserve a limited number of samples from previous tasks to prevent forgetting, whereas exemplar-free approaches [, , ] do not retain any samples from prior tasks.

Due to privacy concerns in many FL systems (e.g., hospitals and research areas), users cannot store any historical data, so the exemplar-free category is of particular interest. Recent works [, , ] in this field tend to generate synthetic data and combine with distilling regularizers [, ] to balance the trade-off between retaining knowledge and learning new tasks. However, experimental results have shown that these works still witness catastrophic forgetting, i.e., bias towards recent classes; see Figure 2(a) and 2(b).

Figure: Figure 1: Illustration of the real-world scenarios in the FCIL setting.
Refer to caption: x1.png

To address this problem, we propose Federated Global Twin Generator (FedGTG), an FCIL framework that does not store any data from clients. After completing one task, the server trains two generative models and shares them with clients on subsequent tasks to create synthetic examples and features of previous classes. On the client side, we propose a synthetic logit distillation using generated features for retaining knowledge, as well as a fine-tuning loss using both real and generated data to balance the ability to predict all classes. However, using only these two objectives still hinders the model’s ability to obtain new knowledge, see Figure 2(c). We argue that this issue happened as the feature directions were not constrained. Therefore, we add a feature-direction-controlling loss, which helps the model to have more plasticity in learning new tasks. As a result, FedGTG achieved extensive performance in terms of accuracy and forgetting measures compared to previous methods, as shown in Section 4.2.

We summarize our contributions below:

- •
We propose an FCIL framework ensuring clients’ privacy by training a data generator and a feature generator on the server side. These generators are distributed to the clients to mitigate catastrophic forgetting.
- •
On the client side, we propose direction-controlling objectives to help the model have a better stability-plasticity trade-off.
- •
We demonstrate the effectiveness of our method in popular benchmarks, including CIFAR-10, CIFAR-100, and tiny-ImageNet, with a 4% increase in accuracy and a 10% decrease in forgetting.
- •
We analyze the robustness of FedGTG compared with recent FCIL algorithms on natural images, as well as test its abilities to converge to flat minima and achieve better predicting confidence.

## 2 Related work and preliminaries

Figure: (a) TARGET
Refer to caption: x2.png

### 2.1 Continual Learning

Catastrophic forgetting [] is a major issue in machine learning where training a model on new data makes it forget its previously learned knowledge. This issue is central to the field of CL, whose primary objective is to build models to acquire new knowledge while retaining information from older tasks. Numerous strategies have been explored to mitigate this problem, including the implementation of regularization terms [, , ], the isolation of architectural parameters [, , ], the use of experience replay through data storage [, , ], and studies of data generation [, , ]. In CL, replay-based methods observe significant performance in terms of accuracy and forgetting measures. However, due to privacy concerns in FCIL, privacy concerns prevent data storage, making these methods inapplicable. An extensive alternative to address this issue is generative-based approaches.

##### Learning tasks

There are three main types of learning in CL: Task-Incremental Learning (Task-IL), Domain-Incremental Learning (Domain-IL), and Class-Incremental Learning (Class-IL) []. In Task-IL, each task is distinct and comes with its own distribution during training and testing. In Domain-IL, the learning task does not change, while different domains or distributions of data sequentially arrive during training. In Class-IL, each new task adds new classes to what the model has to learn, which continually expands the amount of information the model needs to handle.

### 2.2 Federated Class-Incremental Learning

The goal of FCIL is to train a model to learn new classes over time without forgetting previously learned classes while also ensuring that data privacy is maintained across multiple decentralized devices. Several approaches exploit Knowledge Distillation [] to mitigate forgetting by appointing the global model’s weight of the most recent task as a teacher. Continual Federated Learning with Distillation (CFeD) [] constructs server and client-side knowledge distillation using a surrogate dataset, but this costs time and financial resources to collect enough data for this surrogate dataset. Global-Local Forgetting Compensation (GLFC) [] relaxes this problem by training a proxy server globally to ease the imbalance issue between classes.

The above approaches yield extensive performance in past knowledge retention but lack the ability to learn well on new tasks. To alleviate this issue, Federated Class-Incremental Learning (FedCIL) [] trains generators at both client-side and server-side, as well as utilizing knowledge distillation to balance the stability-plasticity trade-off. However, this approach can raise a privacy risk since information about client-side generative models is shared with the server. Federated Class-Continual Learning via Exemplar-Free Distillation (TARGET) [] and Mimicking Federated Continual Learning (MFCL) [] ensures clients’ privacy and limited storage by training a data generator on the global-side and adding distilling regularizers to the client-side training to enhance overall performance. However, as we show in Figure 2, these methods still have bad performance on old classes, leaving catastrophic forgetting mitigation a still desirable goal.

### 2.3 Preliminaries

There are $c$ clients, denoted as $\left\{C_{1},C_{2},\ldots,C_{c}\right\}$ and a central server, denoted as $S$. We consider the Synchronous Federated Continual Learning setting [] where all clients share the same task sequence $T=\left\{T_{1},T_{2},\ldots,T_{n}\right\}$. Specifically, at task $T_{t}$, each client $C_{i}$ has a private dataset $\mathcal{D}^{t}_{i}=\left\{\mathcal{X}^{t}_{i},\mathcal{Y}^{t}\right\}$.

During the first task, the global model $\theta^{1}_{G}$ is obtained after aggregating local models $\left\{\theta^{1}_{1},\theta^{1}_{2},\ldots,\theta^{1}_{s_{1}}\right\}$ using conventional Deep Learning methods, where $s_{1}$ is a number of selected clients among all. From the task $T_{t}$, $t\geq 2$, the global model $\theta^{t-1}_{G}$ can distinguish the samples belonged to the classes set $\bigcup_{i=1}^{t-1}\mathcal{Y}_{i}$. The server then distributes its parameters back to the clients. Client $C_{i}$ uses $\theta^{t-1}_{G}$ as an initial model to train on task $T_{t}$ using its private dataset $\mathcal{D}^{t}_{i}$. The local model $\theta^{t}_{i}$ should perform well in classifying classes from the set $\bigcup_{i=1}^{t}\mathcal{Y}_{i}$. Finally, the server collects the local models from clients who participate in the process after each $r_{t}$ communication round and obtains a new global model $\theta^{t}_{G}$, which can identify classes from the set $\bigcup_{i=1}^{t}\mathcal{Y}_{i}$.

## 3 Metholodgy

### 3.1 Overview

Several approaches [, , ] in the conventional CL achieve significant predicting performance across all classes by storing a small subset of samples from previous tasks in episodic memory. However, this approach is not viable in the FL setting due to privacy concerns (e.g., local hospitals cannot share data with the central server). One initial approach to address this challenge is using generative models, which can generate synthetic data for subsequent training, as demonstrated in earlier studies [, ]. However, as illustrated in Figure 2, only generating synthetic examples still causes catastrophic forgetting in previously learned classes. Therefore, we propose a Federated Global Twin Generator (FedGTG), which can balance the stability-plasticity trade-off and clients’ privacy. This method has two main stages: (1) At the end of each task, the server trains a data generator and a feature generator to capture the information of all seen classes; (2) Clients receive generators from the server to create synthetic information, as well as obtaining global weights as initialization, which helps retain knowledge from previous tasks and learn the new task efficiently. In the following section, we will explain these two stages of FedGTG (Figure 3).

Figure: Figure 3: Illustration of the proposed framework. After completing one task, the server employs a data-free approach to train two generators. The clients then use two types of synthetic information from these generators to train their local models for retaining knowledge and learning new tasks well.
Refer to caption: x7.png

### 3.2 Server-side

#### 3.2.1 Data Generator

Since the server only has access to the global model’s weights, we can only train the data generator using data-free methods, such as DeepInversion. Specifically, we have a generative model that takes a noise $z\sim\mathcal{N}\left(0,1\right)$ as input and produces a synthetic example $\tilde{x}$ mirroring the dimensions of the original training input. This synthetic data should observe the following objectives.

After training task $T_{t}$, the synthetic data should be classified correctly by the global model $\theta^{t}_{G}$, and they should not be biased to any classes. With this aim, we employ a temperature cross entropy classification loss between its assigned label $z$ and the prediction of $\theta^{t}_{G}$ on $G^{t}_{D}\left(z\right)$ as

$$ $\mathcal{L}_{\text{CE}}=\text{CE}_{\text{last}}\left(\text{argmax}\left(z\left [:,q\right]\right),\theta^{t}_{G}\left(\widetilde{x}\right)\right)+\lambda_{ \text{current}}\text{CE}_{\text{current}}\left(\text{argmax}\left(z\left[:,q \right]\right),\theta^{t}_{G}\left(\widetilde{x}\right)\right),$ (1) $$

where $\widetilde{x}$ is the output of $G^{t}_{D}\left(z\right)$, $\text{CE}_{\text{last}}$ and $\text{CE}_{\text{current}}$ respectively are the Cross-Entropy Loss using the truncated outputs of $\theta^{t}_{G}\left(\widetilde{x}\right)$ corresponding with last classes from task $T_{i}$, $i<t$, and current learned classes on task $T_{t}$, and $\lambda_{\text{current}}$ is the temperature hyper-parameter.

Generating synthetic examples can easily be biased to a subset of classes. To maintain the diversity between classes, we utilize the Information Entropy (IE) Loss [] as follows:

$$ $\mathcal{L}_{\text{IE}}=-\mathbf{H}_{\text{info}}\left(\frac{1}{\text{bs}}\sum _{i=1}^{\text{bs}}\theta^{t}_{G}\left(\widetilde{x}_{i}\right)\right),\text{bs : batch size},$ (2) $$

This loss measures the IE for samples of a batch. By maximizing this value, we can promote a more uniform and balanced output distribution from the generator across all classes.

In order to further improve the stability of generator training, we use Batch Normalization Loss [] to make all Batch Normalization layers have the same statistics on synthetic images, as follows:

$$ $\mathcal{L}_{\text{batch}}=\frac{1}{L}\sum_{j=1}^{L}\mathbf{KL}\left(\mathcal{ N}\left(\mu_{j},\sigma_{j}^{2}\right)\parallel\mathcal{N}\left(\widetilde{\mu} _{j},\widetilde{\sigma}^{2}_{j}\right)\right),$ (3) $$

where $L$ is the total number of Batch Normalization layers in the architecture of the global model. $\mu_{j}$ and $\sigma_{j}^{2}$ are the mean and variance stored in Batch Normalization layer $j$ of the global model, $\widetilde{\mu}_{j}$ and $\widetilde{\sigma}_{j}$ are measured statistics of Batch Normalization layer $j$ for the synthetic data.

Adjacent pixels in real images typically have values that are near to one another. One typical method to promote similar patterns in the synthetic images is to add Image Prior Loss []. We can create the smoothed (blurred) version of an image by applying a Gaussian kernel and minimizing the distance of the original and $\text{Smooth}\left(\widetilde{x}\right)$ as

$$ $\mathcal{L}_{\text{smooth}}=\left\lVert\widetilde{x}-\text{Smooth}\left( \widetilde{x}\right)\right\rVert^{2}_{2}.$ (4) $$

In summary, we can write the training objective of $G_{D}$ as follows:

$$ $\min_{G_{D}}\mathcal{L}_{\text{CE}}+\lambda_{\text{IE}}\mathcal{L}_{\text{IE}} +\lambda_{\text{batch}}\mathcal{L}_{\text{batch}}+\lambda_{\text{smooth}} \mathcal{L}_{\text{smooth}},$ (5) $$

where $\lambda_{\text{IE}}$, $\lambda_{\text{batch}}$, and $\lambda_{\text{smooth}}$ are hyper-parameters of specific loss functions.

#### 3.2.2 Feature Generator

As mentioned in Section 3.1, only synthetic images can exacerbate the catastrophic forgetting problem. To address this, we train a feature generator that synthesizes features, capturing the knowledge within the feature space. Like the data generator, this generative model is trained only on the server side. The feature generator takes noise input $z\sim\mathcal{N}\left(0,1\right)$ and produces synthetic features $\tilde{f}$ that match the dimensions of the original features. These synthetic features must meet the following objectives:

##### Temperatured Cross Entropy Loss

After training task $T_{t}$, the generative feature should be classified correctly by the classifier $H^{t}_{G}$ of the global model. Additionally, the synthetic features should not be biased to any classes. With this aim, we employ a temperature cross entropy classification loss between its assigned label $z$ and the prediction of $H^{t}_{G}$ on $G^{t}_{D}\left(z\right)$ as

$$ $\mathcal{L}_{\text{FCE}}=\text{CE}_{\text{last}}\left(\text{argmax}\left(z \left[:,q\right]\right),H^{t}_{G}\left(\widetilde{f}\right)\right)+\lambda_{ \text{current}}\text{CE}_{\text{current}}\left(\text{argmax}\left(z\left[:,q \right]\right),H^{t}_{G}\left(\widetilde{f}\right)\right),$ (6) $$

where $\widetilde{f}$ is the output of $G^{t}_{F}\left(z\right)$, $\text{CE}_{\text{last}}$ and $\text{CE}_{\text{current}}$ respectively are the Cross Entropy Loss using the truncated outputs of $H^{t}_{G}\left(\widetilde{f}\right)$ corresponding with last classes from task $T_{i}$, $i<t$, and current learned classes on task $T_{t}$, and $\lambda_{\text{current}}$ is the temperature hyper-parameter.

##### Feature Information Entropy Loss

The generated features should also not be biased to any subset of classes. Therefore, we adjust the IE Loss (Equation 2) and propose the Feature Information Entropy Loss to make the synthetic feature have this quality, which is

$$ $\mathcal{L}_{\text{FIE}}=-\mathbf{H}_{\text{info}}\left(\frac{1}{\text{bs}} \sum_{i=1}^{\text{bs}}H^{t}_{G}\left(\widetilde{f}_{i}\right)\right),\text{bs: batch size},$ (7) $$

In summary, we can write the training objective of $G_{F}$ as follows:

$$ $\min_{G_{F}}\mathcal{L}_{\text{FCE}}+\lambda_{\text{FIE}}\mathcal{L}_{\text{ FIE}},$ (8) $$

where $\lambda_{\text{FIE}}$ is the hyper-parameter of Feature Information Entropy Loss.

### 3.3 Client-side

From task $T_{t\geq 2}$, on the client side, we have to solve the trade-off between learning the current task quickly (plasticity) and retaining knowledge from previous tasks efficiently (stability). To this end, we divide the learning objectives into two parts.

##### Plasticity

To learn new tasks well, the model needs to learn the new information in a way that is separate from the old classes. To do this, we compute the Cross-Entropy Loss by using only the new classes’ linear heads. Formally, we minimize:

$$ $\mathcal{L}_{\text{CE}}=\text{CE}\left(\theta^{t}\left(x\mid T_{t}\right),y \right),$ (9) $$

where $\theta^{t}\left(x\mid T_{t}\right)$ is model’s output and masking old classes before task $T_{t}$’s linear heads.

##### Stability

To mitigate forgetting, previous approaches leverage knowledge distillation [, ]. However, this can cause information loss in probability space due to squashing functions []. Therefore, motivated by Buzzega et al. [], we propose Synthetic Logits Distillation Loss, which matches the logits of the old and current linear heads. These classifiers take synthetic features as input instead of synthetic data since the feature stores more previous information. Formally, we optimize:

$$ $\mathcal{L}_{\text{logits}}=\left\lVert\theta^{t-1}_{G}\left(\widetilde{f} \right)-\theta^{t}\left(\widetilde{f}\right)\right\rVert,$ (10) $$

where $\theta^{t-1}_{G}$ is the global model trained up to task $T_{t-1}$.

As shown in [], when there is a sudden shift in the distribution of the input of the task sequence, biased features on previous tasks can output biased logits, hindering the ability to obtain new knowledge. To mitigate this shortcoming, from task $T_{t}$, we leverage synthetic data by training it alongside with real data. However, the distribution of synthetic data may vary from that of real data, making it essential to ensure the model does not distinguish between old and new data solely based on these differences. To address this problem, we only use the extracted features of the data. To tackle this issue, we utilize only the extracted features of the data, i.e., clients freeze the feature extraction layers and update only the linear head (represented by $H^{t}$) for both real ($x$) and synthetic ($\widetilde{x}$) images. This Fine-tuning loss is formulated as

$$ $\mathcal{L}_{\text{FT}}=\text{CE}\left(H^{t}\left(\left[f,\widetilde{f}\right] \right),\left[y,\widetilde{y}\right]\right),$ (11) $$

where $f$ and $\widetilde{f}$ respectively are the extracted features of $x$ and $\widetilde{x}$ after passing through the freezed feature extractor $F^{t}$ of the local model, $y$ and $\widetilde{y}$ is the hard label of $x$ and $\widetilde{x}$.

##### Enhancing stability-plasticity

Figure 2(c) shows that the combination of the above objectives reduces the model’s performance across all classes. We contend that this happens because the feature directions are unconstrained, resulting in the total loss failing to converge. We then further add additional loss to balance this problem, named Empirical Feature Matrix Loss [], which constrains directions in feature space most important for previous tasks, while it allows more plasticity in other directions when learning new tasks. In this work, we re-utilize the synthetic features to calculate the Empirical Feature Matrix $E_{t-1}$ from the previous task $T_{t-1}$. We have,

$$ $\mathcal{L}_{\text{EFM}}=\left(F^{t}\left(x\right)-F^{t-1}_{G}\left(x\right) \right)^{\top}\left(\lambda_{E}E_{t-1}+\eta I\right)\left(F^{t}\left(x\right)- F^{t-1}_{G}\left(x\right)\right),$ (12) $$

where $F^{t}$ and $F^{t-1}_{G}$ respectively are the feature extractor of the current model and the previous global model, $\eta$ is the damping term to constrain features to stay in a specific region.

In summary, the final objective on the client side as

$$ $\min_{\theta^{t}}\mathcal{L}_{\text{CE}}+\lambda_{\text{logits}}\mathcal{L}_{ \text{logits}}+\lambda_{\text{FT}}\mathcal{L}_{\text{FT}}+\lambda_{\text{EFM}} \mathcal{L}_{\text{EFM}}.$ (13) $$

## 4 Experimental results

### 4.1 Experimental Setup

In this section, we provide our experimental setup, including the datasets used, FCIL baselines, and implementation details.

##### Datasets

We perform our experiments on three widely-used benchmark datasets in FCIL [, , ], which are the protocol versions in the FCIL setting of CIFAR-10 [], CIFAR-100 [], tiny-ImageNet [], and we name it respectively are Sequential F-CIFAR-10, Sequential F-CIFAR-100 and Sequential F-tiny-ImageNet. The data preparation is explained later in Appendix B. We use Latent Dirichlet Allocation (LDA) [] with $\alpha=1$ to distribute the data of each task among clients.

##### FCIL Baselines

In addition to our FedGTG, we also include one regularization-based method, FLwF-2T [], and two generative-based methods, TARGET [] and MFCL []. The detailed description of these algorithms can be seen in Appendix B.

##### Models and Implementation Details

In all experiments, we train a ResNet-18 [] backbone using the SGD optimizer []. We train the model for $100$ epochs per task on every dataset. Additional implementation details and hyper-parameter configurations are then provided in the Appendix B.

##### Evaluation Metrics

We report the performance of the methods using two metrics: Average Incremental Accuracy and Average Forgetting. Average Incremental Accuracy (AIA) measures the average accuracy of the global model on all tasks after the training finishes. Forgetting ($f_{t}$) of task $T_{t}$ is the difference between the model’s best performance on task $T_{t}$ and its accuracy after completed training. Consequently, Average Forgetting (AF) is the average of all $f^{t}$, from task $T_{1}$ to task $T_{n-1}$, at the end of task $T_{n}$. We report the averaged result over three different random initializations.

### 4.2 Performance Results

Figure: (a) Sequential F-CIFAR-10
Refer to caption: x8.png

**Table 1: Performance of the different baselines in terms of AIA and AF for three datasets. [$\uparrow$] higher is better, [$\downarrow$] lower is better.**
| Method | CIFAR-10 | CIFAR-100 | tiny-ImageNet |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| AIA [$\uparrow$] | AF [$\downarrow$] | AIA [$\uparrow$] | AF [$\downarrow$] | AIA [$\uparrow$] | AF [$\downarrow$] |  |
| FedAVG | $42.82\pm 0.23$ | $55.55\pm 0.58$ | $21.39\pm 0.22$ | $78.67\pm 0.83$ | $13.80\pm 0.19$ | $74.12\pm 0.81$ |
| FedProx | $42.43\pm 0.32$ | $56.15\pm 0.71$ | $21.54\pm 0.32$ | $78.12\pm 0.71$ | $13.69\pm 0.21$ | $75.16\pm 0.79$ |
| FLwF-2T | $52.74\pm 0.23$ | $39.51\pm 0.59$ | $32.19\pm 0.18$ | $50.78\pm 0.63$ | $17.18\pm 0.17$ | $44.51\pm 0.67$ |
| TARGET | $59.19\pm 0.16$ | $17.23\pm 0.45$ | $42.15\pm 0.13$ | $26.45\pm 0.61$ | $19.46\pm 0.25$ | $20.17\pm 0.57$ |
| MFCL | $61.34\pm 0.21$ | $22.32\pm 0.52$ | $45.07\pm 0.12$ | $28.30\pm 0.78$ | $21.47\pm 0.15$ | $23.90\pm 0.58$ |
| FedGTG (Our) | $\mathbf{64.50\pm 0.22}$ | $\mathbf{13.14\pm 0.67}$ | $\mathbf{46.42\pm 0.18}$ | $\mathbf{18.66\pm 0.76}$ | $\mathbf{24.04\pm 0.23}$ | $\mathbf{16.18\pm 0.62}$ |

We present the performance of FedGTG and the baselines. Figure 4 shows the Average Accuracy of the model at each task in the training process. It can be seen that FedGTG achieves state-of-the-art performance in all settings. Specifically, our method observes better Average Accuracy on all later tasks. Table 1 reports both AIA results (higher is better) and AF results (lower is better).

As expected, FedAvg and FedProx suffer the highest forgetting since they are not designed for FCIL. When compared to FLwF-2T, the performance gap between it and our FedGTG is significant, indicating that regularization towards previous parameter sets is insufficient to avoid forgetting. Compared to the generative-replay methods, TARGET and MFCL, our FedGTG achieves the least AF and the best AIA, showing that FedGTG can both retain knowledge and learn new tasks effectively.

### 4.3 Model Analysis

The majority of FCIL research concentrates on testing experiments on ideal benchmarks [, , ], such as CIFAR [] and ImageNet []. This results in a lack of analysis concerning real-world scenarios, such as the decision-making ability required in hospitals or the model’s generalization to diverse environments. Therefore, in this section, we conducted experiments to analyze the robustness of FedGTG and three FCIL algorithms mentioned above on corrupted environments, as well as the qualities of generalization [, , ] and achieve calibrated networks [, ].

##### Robustness to natural corruptions

In the real world, autonomous cars must operate effectively in various environments, including diverse weather conditions. Therefore, it is essential for FCIL algorithms to be robust to naturally corrupted data distributions. We then evaluate our method and the recent FCIL methods on the CIFAR-100-C dataset. This dataset includes 18 augmentations of the original CIFAR-100, inspired by CIFAR-10-C []. Models are trained using standard CIFAR-100 with the same setting in Section 4.1 and tested on CIFAR-100-C. Figure 5 shows robustness to 09 different corruptions averaged over three different runs, the results of the rest augmentations are shown in the Appendix D. Specifically, our approach achieves higher test accuracy on various corruptions, with an average improvement of 5% over MFCL and 8% over TARGET. Evidently, our method offers noticeable advantages in robustness against natural corruption.

##### Converging to flatter minima

Extensive CL algorithms [, , ] explore how well their methods generalize by examining their ability to converge to flat minima. If a model obtains this quality, the loss function values $\mathcal{L}_{\text{CE}}$ increase only slightly, suggesting stable model predictions and demonstrating good train-test generalization. In this part, we compare the flatness of the training minima of FLwF-2T, TARGET, and MFCL with our approach. As done in [], we consider the model at the end of training and add independent Gaussian noise with growing variance to each parameter. This allows us to evaluate its effect on the average loss $\sum_{t=1}^{n}\mathcal{L}^{\left(T_{t}\right)}_{CE}$ across all training examples. As shown in Figures 6(a) and 6(b), MFCL, especially FLwF-2T and TARGET, reveal higher sensitivity to perturbations than FedGTG. This result concludes that FedGTG can achieve better generalization compared to previous methods.

Figure: Figure 5: Robustness to natural corruptions.
Refer to caption: x12.png

Figure: (a) Perturbation [$\downarrow$]
Refer to caption: x14.png

##### Converging to a more calibrated network

Calibration measures how well a learner’s prediction confidence matches its accuracy, with ideal outcomes reflecting true probabilities of correctness. In real-world applications, including weather forecasting [] and econometric analysis [], the calibrating ability of an FCIL algorithm should be investigated. Figures 6(c) and 6(d) show the value of the Expected Calibration Error (ECE) [] across various FCIL methods after completing each task. It can be seen that FedGTG achieves a lower ECE than the others. This indicates that models trained with FedGTG are less over-confident and, consequently, easier to interpret.

##### Robustness to different client sizes

We validate the effectiveness of FedGTG compared to other FCIL algorithms across different client sizes on the tiny-ImageNet dataset. We run experiments by varying the number of total clients (maintaining a consistent participation rate of $0.1$ per round), ranging from 50 to 200, and compare the results. Figures 6(e) and 6(f) demonstrate that our method still outperforms other approaches, achieving an accuracy 4% higher and a forgetting rate 6% lower compared to the next best method, MFCL.

### 4.4 Limitations

In our work, clients require generative models, the global model’s weight from the most previous task, and the current global model, which raises storage burdens between the server and clients. However, there are more benefits than storing actual data. First, the memory required for the generative models does not depend on the class size: as the number of classes increases, clients may need to either delete some stored examples to make space for new ones or expand their memory capacity. In contrast, the size of the generative models remains constant. Moreover, clients can remove the generative models when inactive during a specific round and retrieve them later when rejoining, whereas removing data samples leads to a permanent loss of information.

## 5 Conclusion

This study introduces an FCIL framework that tackles the constraints of limited resources and privacy concerns. We utilize data and feature generative models that have been trained by the server, eliminating the requirement for costly on-device memory for clients. Our experiments provide evidence that our strategy is successful in reducing catastrophic forgetting and surpasses the current state-of-the-art methods. This paper also analyzes the robustness of FCIL algorithms on natural images, as well as testing the qualities of converging to flat minima and calibrated networks.

## Appendix A FedGTG algorithm

Recall that there are $n$ tasks $T_{1}$, $T_{2}$, $\ldots$, $T_{n}$. At task $T_{1}$, the system is trained using the conventional FedAVG algorithm for aggregating the weight from the clients in $R$ communication rounds. At the end of every task, the server trains a data generator and a feature generator without using any information from the clients. From task $T_{2}$, these two generators are sent to the clients, which combine with modified objectives to both retain knowledge and learn new tasks well. We formalize our approach in Algorithm 1 in detail. The code is available at [https://github.com/lucaznguyen/FedGTG](https://github.com/lucaznguyen/FedGTG).

Figure: Algorithm 1 Federated Global Twin Generator

Figure: Algorithm 2 Client-side: Continual Learning

## Appendix B Experimental Setup

In this section, we detail the settings used in our experiments, including datasets, FCIL algorithms, and experimental setups.

##### Datasets

We perform our experiments on three widely-used benchmark datasets, including the FCIL version of CIFAR-10 [], CIFAR-100 [] and tiny-ImageNet []:

- •
Sequential F-CIFAR-10. The CIFAR-10 dataset [] consists of 60,000 $32\times 32$ color images in 10 classes, with 6,000 images per class. There are 50,000 training images and 10,000 test images. We split the training set into five disjoint subsets corresponding to 5 tasks.
- •
Sequential F-CIFAR-100. Sequential F-CIFAR-100 is constructed by dividing the original CIFAR-100 dataset [], which contains 50,000 images belonging to 100 classes, into ten disjoint subsets corresponding to 10 tasks. In this way, each task has 5,000 images from 10 distinct categories, and each class has 500 images.
- •
Sequential F-tiny-ImageNet. Tiny-ImageNet [] is a subset of ImageNet, containing 100,000 images of 200 real objects. We follow settings in [] to form the Sequential F-tiny-ImageNet. In particular, we split the original dataset into ten non-overlapping subsets. We consider each subset as a task whose images are labeled by 20 different classes, and each class has 500 samples.

##### FCIL Baselines

In addition to our FedGTG, we also include one regularization-based method, FLwF-2T [], and two generative-based methods, TARGET [] and MFCL []. FLwF-2T utilize knowledge distillation both on the server side and client side to ease the catastrophic forgetting issue. TARGET utilizes a global model to transfer knowledge from past tasks to the current task while also training a generator to generate synthetic data, mimicking the overall data distribution across clients. MFCL employs a generative model to create samples from previous distributions, which are then combined with training data to prevent catastrophic forgetting. Both of these algorithms ensure privacy by training the generative model on the server using data-free techniques after each task without client data retrieval.

##### Implementation Details

Table 2 shows our settings and the hyper-parameter tuning for each dataset.

## Appendix C Generative model setup

##### Data Generative Model Architecture

Figure 7 presents the architecture of the data generative models used for the Sequential F-CIFAR-10, Sequential F-CIFAR-100, and Sequential F-tiny-ImageNet dataset. In all experiments, the global model is based on the ResNet-18 backbone.

Figure: (a) Sequential F-CIFAR-10 and Sequential F-CIFAR-100.
Refer to caption: x21.png

##### Feature Generative Model Architecture

The architecure of the feature generative models is illustrated in Figure 8, which employed for the Sequential F-CIFAR-10, Sequential F-CIFAR-100, and Sequential F-tiny-ImageNet datasets. As the outputs are feature vectors, only fully connected layers are needed.

Figure: (a) Sequential F-CIFAR-10 and Sequential F-CIFAR-100.
Refer to caption: x23.png

##### Information generation

To create synthetic data, clients sample i.i.d. noise, which is used to determine the classes through the application of the argmax function to the first $q$ elements, where $q$ represents the total number of classes observed. Since the noise is sampled i.i.d., each class has an equal probability of $\frac{1}{q}$ for sample generation.

**Table 2: Detail settings across three datasets.**
| Setting | Dataset | CIFAR-10 | CIFAR-100 | tiny-ImageNet |
| --- | --- | --- | --- | --- |
| Experimental setup | Image size | $32\times 32$ | $32\times 32$ | $64\times 64$ |
| Task number | 5 | 10 | 10 |  |
| Classes per task | 2 | 10 | 20 |  |
| Samples per task | 5000 | 500 | 500 |  |
| Learning rate | 0.1 | 0.1 | 0.1 |  |
| Weight decay | 0.1 | 0.1 | 0.1 |  |
| Batch size | 32 | 32 | 32 |  |
| Synthetic batch size | 32 | 32 | 128 |  |
| Communication round | 100 | 100 | 100 |  |
| Local epoch | 10 | 10 | 10 |  |
| Hyper-parameter tuning | $\lambda_{\text{IE}}$ | 1.0 | 1.0 | 1.0 |
| $\lambda_{\text{batch}}$ | 1.0 | 1.0 | 1.0 |  |
| $\lambda_{\text{smooth}}$ | 1.0 | 1.0 | 1.0 |  |
| $\lambda_{\text{FIE}}$ | 1.0 | 1.0 | 1.0 |  |
| $\lambda_{\text{current}}$ | 1.5 | 1.5 | 2.0 |  |
| $\lambda_{\text{FT}}$ | 1.0 | 1.0 | 1.0 |  |
| $\lambda_{\text{logits}}$ | 0.1 | 0.1 | 0.05 |  |
| $\lambda_{\text{EFM}}$ | 0.005 | 0.005 | 0.005 |  |
| $\lambda_{\text{E}}$ | 10.0 | 10.0 | 10.0 |  |
| $\eta$ | 0.1 | 0.1 | 0.1 |  |

## Appendix D Additional results

In this section, we show additional results about the robustness of testing on natural images across our method and other FCIL methods. Figure 5 shows the last 09 augmentations of the CIFAR-100 dataset averaged over three different runs. Our approach still outperforms MFCL and TARGET in terms of test accuracy.

Figure: Figure 9: Robustness to natural corruptions.
Refer to caption: x25.png

## Appendix E Ablation Study

**Table 3: Ablation study for FedGTG on Sequential F-CIFAR-100.**
| w/o Loss | $\mathbf{\mathcal{A}^{1}}$ | $\mathbf{\mathcal{A}^{2}}$ | $\mathbf{\mathcal{A}^{3}}$ | $\mathbf{\mathcal{A}^{4}}$ | $\mathbf{\mathcal{A}^{5}}$ | $\mathbf{\mathcal{A}^{6}}$ | $\mathbf{\mathcal{A}^{7}}$ | $\mathbf{\mathcal{A}^{8}}$ | $\mathbf{\mathcal{A}^{9}}$ | $\mathbf{\mathcal{A}^{10}}$ | $\mathbf{\mathcal{A}}$ | $\mathbf{\mathcal{F}}$ |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| $\mathcal{L}_{\text{IE}}$ | $72.40$ | $56.60$ | $46.96$ | $38.22$ | $33.18$ | $30.73$ | $28.50$ | $25.05$ | $23.98$ | $22.37$ | $33.95$ | $37.31$ |
| $\mathcal{L}_{\text{batch}}$ | $72.40$ | $55.62$ | $48.67$ | $41.25$ | $33.48$ | $30.08$ | $27.10$ | $22.98$ | $22.48$ | $21.41$ | $33.67$ | $41.42$ |
| $\mathcal{L}_{\text{smooth}}$ | $72.40$ | $57.15$ | $49.10$ | $41.85$ | $39.44$ | $37.58$ | $34.67$ | $31.15$ | $30.50$ | $29.20$ | $38.96$ | $29.36$ |
| $\mathcal{L}_{\text{FIE}}$ | $72.40$ | $56.35$ | $47.96$ | $37.22$ | $34.18$ | $32.61$ | $29.82$ | $26.17$ | $24.98$ | $23.03$ | $34.70$ | $33.42$ |
| $\mathcal{L}_{\text{FT}}$ | $72.40$ | $41.80$ | $34.67$ | $29.25$ | $22.68$ | $17.60$ | $15.17$ | $13.06$ | $12.59$ | $12.09$ | $22.10$ | $11.66$ |
| $\mathcal{L}_{\text{logits}}$ | $72.40$ | $57.15$ | $49.77$ | $43.05$ | $39.36$ | $37.72$ | $35.67$ | $33.19$ | $32.73$ | $31.62$ | $40.03$ | $25.35$ |
| $\mathcal{L}_{\text{EFM}}$ | $72.40$ | $56.30$ | $48.77$ | $42.53$ | $39.56$ | $37.28$ | $35.37$ | $31.91$ | $31.66$ | $29.92$ | $39.26$ | $27.38$ |
| FedGTG (ours) | $72.40$ | $57.95$ | $54.85$ | $50.20$ | $47.45$ | $44.95$ | $41.00$ | $39.01$ | $37.92$ | $36.46$ | $46.42$ | $18.66$ |

In this section, we highlight the significance of each loss within our proposed framework, analyzing both server and client contributions by sequentially removing components to observe their effects. Table 3 shows our results, where each row corresponds to the removal of a specific loss component, and the columns display the corresponding Average Accuracy ($\mathcal{A}^{t}$), for $1\leq t\leq 10$, Average Incremental Accuracy ($\mathcal{A}$), and Average Forgetting ($\mathcal{F}$) from our proposed method. Specifically, we can see that the performance of the model is influenced by generative models, as poorly trained ones result in low AIA and high AF compared to others. Nevertheless, the Fine-tuning Loss has the lowest AF among all just because it did not learn tasks well (lowest AIA). The final two rows illustrate how the feature-constraining losses ($\mathcal{L}_{\text{logits}}$ and $\mathcal{L}_{\text{EFM}}$) impact the performance of the global model, where the decrease in accuracy demonstrates the importance of these two losses.

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 3
presentation: 4
questions: Why do you design the model architecture of data and feature generation as you shown in the paper? Are there any key ideas of why using these architectures?
soundness: 2
strengths: 1. The paper writing is clear and easy to follow.
2. The proposed FedGTG absorbs the advantage of many other algorithms, leading to a strong framework for FCIL.
3. The experimental results are good. The proposed FedGTG outperforms all baselines on each benchmark and each incremental task. And the ablation study shows that each loss term is crucial and  has a large impact on the final results.
summary: This paper introduce FedGTG (Federated Global Twin Generator), a novel FCIL framework that leverages generative models on the server side without accessing client data. FedGTG trains a data generator and a feature generator to produce synthetic representations of all seen classes, which are then shared with clients to help balance knowledge retention (stability) and learning new tasks (plasticity). Through extensive experiments on CIFAR-10, CIFAR-100, and tiny-ImageNet, FedGTG shows significant improvements in both accuracy and resistance to forgetting
weaknesses: 1. The proposed lacks enough novelty. All loss functions used in FedGTG are proposed by other papers.
2. The framework contains too many hyperparameters, as each loss term needs one. It seems the framework is hard to be finetuned to the optimal result, as there are too many combinations of choice of hyperparameters. And the paper lacks the experiments and discussion of these hyperparameters.
3. More baselines should be compared. Except for generative-based methods, authors should compare FedGTG with other SOTA FCIL algorithms.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 2
questions: see weaknesses.
soundness: 3
strengths: 1. The paper is overall well-written in terms of writing.
2. The introduction part clearly especify the problem about generators.
3. The experiments are showing nontrivial improvements over compared techniques.
summary: This paper introduces Federated Global Twin Generator (FedGTG), and proposes a framework leveraging generative models on the global side, sending synthetic data to clients for retaining knowledge and learning new tasks effectively. FedGTG shows enhanced accuracy, reduced forgetting, and robustness against domain shifts on CIFAR-10, CIFAR-100, and tiny-ImageNet.
weaknesses: 1. Not clear what the biggest contributions are. Is it the two generator structure? If so, the novelty does not seem very high. The paper also introduces a direction-controlling objective, which should also stand out, but not very clearly in the paper (e.g., Figure 1).
2. Need to include training time or cost in the comparison. It seems that training two generators are quite costing, and it already needs more parameter during the training.
3. Is the method an exemplar-free technique? If so, the literature reviewer is not very complete. Quite a few new works on exemplar-free CIL are missing in the continual learning section, such as the analytic continual learning branch [1-3], and prototypes-based CIL.

[1] "ACIL: Analytic class-incremental learning with absolute memorization and privacy protection." Advances in Neural Information Processing Systems 35 (2022): 11602-11614.

[2] "GKEAL: Gaussian kernel embedded analytic learning for few-shot class incremental task." Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition. 2023.

[3] "DS-AL: A Dual-Stream Analytic Learning for Exemplar-Free Class-Incremental Learning." Proceedings of the AAAI Conference on Artificial Intelligence. Vol. 38. No. 15. 2024.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: - Does this work focus on cross-silo or cross-device FL? What is the number of clients evaluated?
- What is the meaning of “stability-plasticity” ?
soundness: 3
strengths: - The propose method of using an additional generator is simple and intuitive, while it is not straightforward to make it work. It is technically sound that the authors propose additional loss functions to stablize the training. 
- The paper is generally well-written and easy to follow.
- Extensive experiments are conducted through 3 datasets with detailed ablation studies. Sufficient exisiting works are compared. The proposed method achieves much strong performance than the compared counterparts.
summary: - This paper focuses on federated continual learning, federated class-incremental learning to be more specific. It proposes a new method of using two generator to generate synthetic data and feature. The synthetic data and feature are sent to the client for local training. In local training, this work proposes multiple losses to improve the training process.
weaknesses: - Figure 1 is not easy to  understand. It would be useful if the authors could provide more explanations or making it more intuitive.
- The abstract claims that “these approaches’ testing accuracy in previous classes is still much lower than recent classes”, but it seems the paper does not provide experiments showing that the proposed method addresses this issue.
- It seems that only a single backbone is used in the evaluatiion. 
- Typo in line 83, should be “methods”.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: see weakness
soundness: 3
strengths: 1. This paper enhances current GAN methods for Federated Incremental Learning by integrating both a feature GAN and a data GAN, with the feature GAN employing regularization to achieve improved performance and stability across incremental tasks.  
2. Extensive experiments across multiple datasets demonstrate the robustness and validity of the proposed model, showcasing its effectiveness in various scenarios.  
3. Unlike prior GAN-based methods, which often suffer from catastrophic forgetting, this work introduces innovative mechanisms that significantly mitigate such issues, representing a valuable contribution to the field.
summary: Federated Learning (FL) is a privacy-preserving machine learning approach, but it faces challenges related to resource limitations and data heterogeneity, especially as client data distributions evolve over time. Federated Class-Incremental Learning (FCIL) combines FL and Class-Incremental Learning (CIL), enabling models to continuously learn new knowledge from distributed data sources without forgetting prior knowledge. However, existing methods such as TARGET and MFCL, which use data generation to balance knowledge retention for new and old tasks, still encounter forgetting issues. To address this, this paper proposes the Federated Global Twin Generator (FedGTG) framework, which trains and shares data and feature generators on the server side, using direction-control loss to enhance stability and plasticity on the client side. Experiments demonstrate that FedGTG outperforms existing methods in terms of accuracy and forgetting rate.
weaknesses: 1. The experiments in the paper lack critical details, including the ratio of generated data used in each training cycle, the proportion within individual batches, and the hyperparameters for each loss function, which should ideally be explored through ablation studies. Additionally, the class-incremental setup is not clearly explained, leaving me unsatisfied with the experimental rigor.

2. The datasets used throughout the paper are relatively simple; I recommend conducting further experiments on high-resolution datasets such as ImageNet to strengthen the evaluation.

3. The contributions of the paper are limited. For instance, incorporating a feature GAN as a regularization term is not substantially different from traditional regularization methods in incremental learning.

4. It is unclear whether the GAN trained after each task is independently trained or incrementally trained based on the previous task. If trained independently, this approach would impose excessive storage and communication costs; if incrementally trained, the GAN itself could suffer from catastrophic forgetting. These aspects present limitations in the proposed method.

Meta-review: This paper introduces FedGTG (Federated Global Twin Generator), a framework that leverages generative models on the server side without accessing client data. The main idea is quite simple, using two generators to generate synthetic data and features, which are sent to the client for local training. One common concern shared by multiple reviewers is the novelty of the paper. In particular, as pointed out by reviewers, the main loss function design for local training boils down to a combination of existing losses in the literature, and it lacks principled justification on why one should do so. The authors' responses answered some of the clarification questions from the reviewers but the key limitation still remains. The reviewers have reached a consensus of not accepting the paper.

Decision: Reject