Core Tokensets for Data-efficient Sequential Training of Transformers

## Abstract

Abstract Deep networks are frequently tuned to novel tasks and continue learning from ongoing data streams. Such sequential training requires consolidation of new and past information, a challenge predominantly addressed by retaining the most important data points - formally known as coresets.
Traditionally, these coresets consist of entire samples, such as images or sentences. However, recent transformer architectures operate on tokens, leading to the famous assertion that an image is worth 16x16 words. Intuitively, not all of these tokens are equally informative or memorable. Going beyond coresets, we thus propose to construct a deeper-level data summary on the level of tokens.
Our respectively named core tokensets both select the most informative data points and leverage feature attribution to store only their most relevant features. We demonstrate that core tokensets yield significant performance retention in incremental image classification, open-ended visual question answering, and continual image captioning with significantly reduced memory. In fact, we empirically find that a core tokenset of 1% of the data performs comparably to at least a twice as large and up to 10 times larger coreset.

## 1 Introduction

Deep learning models are rarely deployed in static environments and instead need to be continuously adjusted to their ever-changing surroundings. As distribution shifts occur over time, we require models to retain their performance on previous settings while accommodating new examples (Hadsell et al., ; Kudithipudi et al., ; Mundt et al., ). Naively, re-training a model from scratch for every change in the environment quickly becomes unfeasible for complex architectures with billions of parameters (Touvron et al., ; Brown et al., ). Consequently, research has focused on identifying small, representative subsets of the training data (Lopez-Paz & Ranzato, ), which can later be replayed continuously to avoid (catastrophic) forgetting (McCloskey & Cohen, ) of previously acquired information (Graham et al., ; Hassani et al., ; Xu et al., ). Formally, these (weighted) subsets can be described as coresets; data summaries that approximate the original loss function with a negligible loss in performance (Bachem et al., ; Blömer et al., ; Trapp et al., ). However, whereas multiple successful coreset selection techniques were proposed (Mirzasoleiman et al., ; Killamsetty et al., ), we argue that modern architecture advances now allow for a yet to be leveraged level of data summarization. In particular, (vision) transformers now conveniently define each data input as an ordered set of tokens (Vaswani et al., ; Dosovitskiy et al., ). In turn, we posit that it is not only a subset of the data instances that allows effective summarization but also only a handful of features within every data point that may be relevant to generalizing the task at hand. We refer to the latter as core tokens and, respectively, the subset of most meaningful tokens of important data instances as core tokensets.

Core tokensets build on the general principle of coresets, where we aim to identify the tokens that approximate the loss within a negligible error margin of the full dataset. To this end, we demonstrate that the attribution maps calculated using the attention scores across the transformer layers, as a means to understand the relevance of each token, can serve as the basis for core token selection. In practice, we thus explore different strategies to determine the token’s relevance, e.g. by exploiting the gradients or perturbing the attention scores. Our first interesting insight is that naively retaining only core tokens from each data sample at a specified rate results in a similar cost as an involved coreset (that selects a subset of data instances) with an identical retention rate. However, and more importantly, we can couple techniques in a two-fold subset selection approach, i.e., our so-called core tokensets, where we first identify a subset of samples using coreset selection methods and then select core tokens of those samples. A schematic overview of our framework is depicted in Fig. 1. We demonstrate the benefits of core tokensets in the scope of sequential training tasks, where we show that storing only the relevant partial inputs yields informative summaries with both improved performance as well as significantly reduced memory buffer size in comparison to state-of-the-art traditional core sets. In summary, we make the following contributions:

- •
We introduce the notion of core tokensets, a sub-data summary that selects a subset of most important tokens for a subset of most important data instances of a dataset.
- •
We show how to leverage the attribution maps computed across the transformer layers in an exploration of various strategies to select the most influential tokes.
- •
Finally, we extensively highlight the empirical performance and memory benefits of core tokensets in different sequential task setups in image classification, multi-modal image captioning, and multi-modal question-answering.

Figure: Figure 1: Continued training with core tokensets. In sequential training, forgetting previous tasks is mitigated by selecting the most meaningful previously observed data points and storing only their most influential tokens (yellow shaded parts; left side). The resulting core tokenset is then interleaved in the training of new tasks (blue shaded parts; right side), where random input dropout is further employed to render the model susceptible to observing partial inputs.
Refer to caption: x1.png

## 2 Preliminaries and Related Work

Coresets: Conventional dataset summaries are constructed as instance-wise (weighted) subsets of the entire training data. These coresets are comprised of the most informative instances with an aim to approximate the full dataset with a negligible difference in the cost function. That is, we wish to find the subset $C_{x}$ of $D$, assuming an additively, into non-negative functions decomposable, cost function for our given dataset $D$ (Bachem et al., ; ), such that for any solution (parameters) $Q$:

$$ $|\mathtt{cost}(D,Q)-\mathtt{cost}(C_{x},Q)|\leq\epsilon\cdot\mathtt{cost}(D,Q) ,\;\;where\;\epsilon>0$ (1) $$

In practice, coresets were primarily designed to demonstrate dataset approximation capabilities for traditional machine learning models such as K-means (Blömer et al., ; Feldman et al., ; Har-Peled & Kushal, ), SVM (Dong et al., ), and logistic regression (Huggins et al., ), with very few works aimed at deep neural networks (DNNs).
For the latter, Killamsetty et al. () resorts to bi-level optimization to solve the selection of coresets as an outer objective and the generalization of model parameters as an inner objective. However, it requires several optimization steps, which can be impractical for complex architectures. As an alternative to bi-level optimization, gradient-based coreset approaches have thus emerged. Their main premise is to solve an alternative to Eq. 1 that operates on the gradients of the loss rather than approximating the loss directly. As such, the recently proposed CRAIG (Mirzasoleiman et al., ) aims to identify the optimal coreset by converting the gradient matching problem to a monotone submodular function optimization problem and solving it with a pre-defined error bound. Similarly, GradMatch (Killamsetty et al., ) matches the coreset with the full datasets gradients while additionally employing L2 regularization to reduce dependency on any specific data sample.

In sequential learning, coresets can effectively be used as replay buffers to interleave in continued training (Mundt et al., ) to avoid catastrophic forgetting (McCloskey & Cohen, ). However, prominent replay strategies rely on ad-hoc subset selection, such as reservoir or random sampling (Rolnick et al., ; Kumari et al., ; Tiwari et al., ), to retain previously acquired information over the course of training. In our work, we evaluate the impact on transformers to solve more complicated tasks beyond standard classification problems, such as sequential visual question answering and sequential image captioning and propose an advanced data summarization technique for transformers, referred to as core tokensets.

Transformer preliminaries: Given a sample $X$, transformers (Vaswani et al., ) make use of a sequence of tokens $x_{p}$, where each token captures distinctive features of the data sample. Usually, for images, the samples are transformed into $T$ equally sized $P\times P$ flattened 2D patches $x_{p}\epsilon\mathbf{R^{T\times(P^{2}F)}}$ ($F$: number of feature channels). Subsequently, each patch is encoded into a single token embedding $\mathbf{E}^{t}\in\mathbf{E}$; every embedded patch is then concatenated with its corresponding positional embedding vector $\mathbf{E}_{pos}^{t}\in\mathbf{E}_{pos}$. The self-attention layers then process these sequences of token embeddings $z_{0}$:

$$ $z_{0}=[x_{cls};x_{p}^{1};x_{p}^{2};...;x_{p}^{T}]\textbf{E}+\textbf{E}_{pos}$ (2) $$

## 3 Core Tokensets: Summarizing Datasets with Informative Tokens

As transformers are now capable of processing data inputs as a sequence of multiple tokens, we now present a novel way to summarize datasets even more efficiently than traditional coresets.

Definition:
A Core Tokenset $C_{t}$ is a subset of tokens ($\subseteq T$) of a dataset $D$, such that a solution $Q$ found on the core tokenset approximates the cost of the full dataset within negligible error margin: $|\mathtt{cost}(T,Q)-\mathtt{cost}(C_{t},Q)|\leq\epsilon\cdot\mathtt{cost}(T,Q).$

This definition is a modification of core set equation 1. Instead of being based on data instances, it is now based on tokens and we can thus leverage the unique architectural properties of modern transformers to process inputs at a sub-data point level. In order to identify the core tokens, we associate each input token $x_{p}^{t}$ with a binary importance variable $v^{t}$:

$$ $\displaystyle C_{t}:=\{(x_{p}^{t},t)|v^{t}=1,0<=t<|z_{0}|\}\;s.t.{|C_{t}|<T}$ (3) $$

Note that, each stored core token remains associated with its position $t$, preserved in the form of integer indexes of the extracted tokens. This will later be used to preserve original structure in continued training. The importance variable will typically be regulated by the relevance of the token to its current task, but we can also think of straightforward selection methods. For instance, a naive (random) selection can be realized by sampling the importance variable from a Bernoulli distribution: $v^{t}\sim Bernoulli(r)$. Here, $r$ naturally maps to our key hyperparameter, i.e. the retention rate that reflects the percentage of tokens retained from $T$.

Whereas there exist well-defined strategies to determine coresets, methods to select core tokens are yet to be explored. Even though random sampling is a feasible baseline in forming memory (Hayes et al., ), randomly selecting core tokens can easily lead to storing redundant tokens. In particular, in images, the object of interest often only occupies tiny regions of an input sample; storing the background alone is unlikely to approximate the true loss well. As a remedy, we propose to leverage attribution techniques and propose to investigate the attention maps for token relevance to construct our set of core tokens. First, each token is assigned a relevance score, determining its contribution towards the prediction. We then draw inspiration from “interpretability” techniques (Chefer et al., ; Deiseroth et al., ) to further elevate the efficacy of attribution maps to calculate the token relevance score. For instance, we can perturb the attention scores across the blocks or calculate the gradients across the transformer blocks to quantify the contribution towards the final prediction.

Let us specifically outline the gradient-based approach to select core tokens. Given a transformer model with B blocks, we first calculate the attention map ($A^{b}$) for each block ($b\in B$) comprising h attention heads. We consider the Hadamard product of the gradients of the attention map ($\nabla A^{b}$) and the layer-wise relevance score ($L_{R}$) (Bach et al., ) with respect to a target class. The final attribution map $\bar{A^{b}}$ is achieved by calculating the mean ($E_{h}$) of the product across h attention heads in addition to an identity matrix to account for skip connections in transformers.
The final influence matrix $S_{T\times T}$ is then defined by multiplying all the attention head scores, where each row consists of the relevancy score of each token compared to the other token.

$$ $\displaystyle\bar{A^{b}}=\textit{I}+E_{h}(\nabla A^{b}\odot L_{R});$ $\displaystyle S_{(T\times T)}=\bar{A^{(1)}}\cdot\bar{A^{(2)}}\cdot\bar{A^{(3)} }\cdot\bar{A^{(B)}}$ (4) $$

From the influence matrix, we extract the relevance of each token, which will ultimately determine the individual binarized $v_{t}$. For classification, we only consider the class token in the first row. The top values then lead to extraction of the core token into our set. The cardinality of the set is pre-determined based on the chosen retention rate $R$ such that $\frac{|C_{t}|}{|T|}=R$. Intuitively, such a gradient-based core token selection strategy is related to earlier described gradient matching strategies for core set selection. We determine the most influential tokens of each data point via analysis of the gradients and store a subset that approximately leads to the same outcomes as the entirety of all tokens.

## 4 Sequential Training with core tokensets

When we train our transformer sequentially over time, we optimize our model simultaneously on newly arriving data of the novel task and the memory buffer data as modeled through the core tokenset. The training loss $\mathcal{L}$ is thus:

$$ $\mathcal{L}=E_{(x,y)}\hskip 2.0pt\mathcal{L}(f(x),y)+E_{(x_{p}^{c},y)\in C_{t} }\hskip 2.0pt\mathcal{L}(f(x_{p}^{c}),y)\quad$ (5) $$

where $\mathcal{L}(.,.)$ denotes an arbitrary loss (e.g. the cross-entropy), $f$ denotes the model predictions $f=z(g(x))$ and $g(x)$ is the shared encoder model. Similarly, $f(x_{p}^{c})$ denotes the predictions made on the core tokenset memory buffer.
Before we proceed to experimentally corroborate our core tokensets, let us first consider two further imperative aspects: 1.) how to make transformers susceptible to the partial inputs (subset of tokens) stored in our data summary, and 2.) provide an intuition for the trade-offs and interplay between storing a traditional core set and a subset of tokens.

### 4.1 Making Transformers susceptible to Partial Inputs

During regular (pre-)training, ViTs only observe complete inputs of $T$ tokens. If we now feed them with a subset of tokens, i.e. drop a subset of the concatenated patches, this results in an input sequence that strongly deviates from the expected input structure. This, unfortunately, immediately leads to unexpected model behavior and performance degradation. In fact, in Fig. 2(a) we report the latter, in an experiment where we transition from training on complete samples during initial training to fine-tuning on partial inputs with core tokensets. Specifically, a pre-trained ImageNet (Deng et al., ) Vit-B/16 model is continuously fine-tuned to 20 random classes first on all data and then on core tokenset with different retention. For simplicity, we randomly select the core tokens. We can observe a considerable drop in performance of roughly 15% in prediction accuracy at 30% retention.

If one were to draw premature conclusions, one would posit that core tokens are ineffective. However, this is not the case and our initial deteriorated model performance is truly due to the model encountering unexpected input. As a remedy, we demonstrate that we need only make the model amenable to observing partial inputs. Whereas we could conceive several notions to achieve the latter, an effective simple strategy is to ensure that the model is always prompted with a complete sequence of $T$ tokens for core tokens. To that extent, the input value of left out tokens is set to $\mathbf{0}$. Crucially, this setup preserves the input structure on which the model was pre-trained, thus ensuring that spatial relations of patches are represented correctly. To emulate the respective sparsity of core tokensets, we additionally randomly zero-out tokens of full data samples according to the expected retention rate, similar to dropout (Srivastava et al., ) applied to the input. In Fig. 2(b), we again tune a pre-trained vision transformer (ViT) on 20 classes of ImageNet but now with random dropping and subsequently fine-tuning on sets of core tokens. We fix the retention rate $R$ at 30% for core tokens while varying the drop rate used during the initial 20-class training. We see that the use of dropping tokens is imperative to avoid performance drops. As we match the drop rate with the retention rate, the model becomes more adept at learning from core tokens. Eventually, we retain the initial performance, much in contrast to the earlier curve (also green, in panel a) without any training amendments.

For sequential learning on the combined token $\mathbf{[\{x_{p}^{t}*v^{t}\}_{t=1}^{T}\uplus\{x_{p}^{c}\}_{c=1}^{C_{t}}]}$, we thus adopt above practical strategy. That is, we additionally randomly sample $v^{t}\sim Bernoulli(r)$ for the newly observed complete data repeatedly during training, i.e. we randomly drop input tokens. The core tokenset already has been attributed its relevance, i.e. a respective $v^{c}$ is always unity following one of the earlier described selection strategies. It is here, where we make use of the stored integer positions of the core tokenset in order to pad the remainder with zeros. In Fig. 3, where we sequentially tune on ImageNet subsets sequentially, our strategy consistently retains performance, whereas naive training on the core tokenset deteriorates heavily.

Figure: (a) Naive training with core tokens
Refer to caption: x2.png

### 4.2 Intuition on Effectiveness: Coresets vs. Core Tokensets

Our definition of core tokens naturally raises the question of whether it is more beneficial to store subsets of tokens or subsets of data points, or whether to combine the latter. To provide intuition for this question, we conceive two practical variants of data summarization. The first strives to identify the most relevant subset of tokens for every data point and use this as a data summary. We will refer to this idea as only extracting core tokens. In the second, we would instead attempt to find the most important subset of data points and respectively their most influential tokens. We will refer to the latter when we proceed to speak of core tokensets in the remainder of the paper’s experiments. In other words, core tokenset follow earlier Fig. 1, where we first build a coreset and then subsequently identify the core tokens for the selected samples, whereas only selecting core tokens can be seen as an ablation omitting the core set step.

In Fig. 4 we evaluate these two strategies, only core tokens and core tokensets, against traditional core sets for our pre-trained ViT-B model on 20 random ImageNet classes with varying retention rates (10-100%). We can observe that for all retention rates, training on core tokens outperforms traditional core sets. However, core tokensets, identifying the most important tokens for the most important data points, yield substantial further performance improvement. We believe this to be fairly intuitive. For instance, consider a budget where we store only 1% of the samples in our memory buffer; coreset techniques, most evidently, will throw away 99% of the total data instances. Meanwhile, for core tokens, it will be possible to store 1% of information for every single item of dataset. In contrast, for core tokensets, the combination allows us to select more instances than the coreset technique by focusing on a few core tokens per sample. To be precise, we can store 10% of the samples ($>$ 1% coresets) and 10% of the tokens ($>$ 1% core tokens) of those samples at the same memory budget. We continue to extensively corroborate these findings in our experimental section.

Figure: Figure 3: Influence of token dropout. We perform continual training (CT) on five distinct sub-tasks. Randomly dropping tokens of novel inputs leads to an improvement of 40% in accuracy, in contrast to a scenario where the model is unable to handle the partial input of core tokensets.
[Uncaptioned image]: x4.png

### 4.3 Experimental Details

Datasets and Models.
We use ImageNet100 (Deng et al., ) for classification, which we sequentially segment into five tasks with 20 unique classes each. For visual question answering, we train on three separate visual question answering datasets in sequence, namely VQA 2.0 (Antol et al., ), CLEVR (Johnson et al., ), and Visual Genome (Krishna et al., ). For the image captioning experiments, we rely on MS COCO (Lin et al., ), which we segment into five equally sized tasks based on the object classes. We start with a pre-trained VIT-B/16 trained on ImageNet21k as our base model (Wightman, ) for image classification to focus our investigation on data summary efficiency and knowledge retention. Lastly, we use a pre-trained BLIP model (Li et al., ) as initialization for both VQA and image captioning tasks. More details for datasets and training set-ups are provided in Appendix A.3. Depending on the complexity of the task, we have trained our models on 8-12 Nvidia A100 GPUs.

Strategies. We evaluate two recent state-of-the-art coreset approaches, namely CRAIG (Mirzasoleiman et al., ) and GradMatch (Killamsetty et al., ), both relying on gradients for their data selection. In addition, we consider four distinct feature attribution methods to derive attention maps, based on which core tokens are selected. *Rollout* considers the information flow from the input layer to deeper ones (Abnar & Zuidema, ). In contrast, *Grad-Cam* relies on the gradients for each input token with respect to the ground-truth output.
Going a step further, gradients with layer-wise relevance propagation (*Grad-LRP*) (Chefer et al., ; ) considers the respective relevance of each layer individually. Finally, *AtMan* (Deiseroth et al., ) calculates the influence of each token by perturbing the attention scores. We provide detailed descriptions for each strategy in Appendix A.1.

**Table 1: Obtained final accuracy in sequential image classification for different subset selection strategies as a function of retained data percentage. Extraction of core tokens performs comparably to modern core set selection methods. However, the conjunction into core tokensets, here specifically combining GradMatch and Atman, consistently yields large accuracy improvements. Color coding is further used to highlight similar performance of a traditional state-of-the-art coreset and our proposed core tokensets. Across various retention rates, core tokensets can even be observed to perform comparably or favorably to much larger sized alternative approaches.**
|  | Retention rates: Sequential Image Classification |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | Methods | 80% | 60% | 40% | 20% | 10% | 1% |
| Coreset | Random | $81.91_{\pm 0.09}$ | $78.19_{\pm 0.15}$ | $75.61_{\pm 0.24}$ | $71.21_{\pm 0.87}$ | $69.22_{\pm 0.43}$ | $67.21_{\pm 0.61}$ |
| CRAIG | $82.97_{\pm 0.02}$ | $81.42_{\pm 0.02}$ | $79.34_{\pm 0.02}$ | $74.82_{\pm 0.05}$ | $73.99_{\pm 0.06}$ | $71.23_{\pm 0.08}$ |  |
| GradMatch | $82.99_{\pm 0.02}$ | $81.58_{\pm 0.02}$ | $79.84_{\pm 0.02}$ | $74.92_{\pm 0.05}$ | $74.21_{\pm 0.08}$ | $71.67_{\pm 0.11}$ |  |
| Core Token | GradCam | $82.19_{\pm 0.09}$ | $78.69_{\pm 0.12}$ | $76.21_{\pm 0.01}$ | $71.33_{\pm 0.23}$ | $69.81_{\pm 0.31}$ | $67.81_{\pm 0.31}$ |
| Rollout | $82.89_{\pm 0.09}$ | $79.98_{\pm 0.15}$ | $78.97_{\pm 0.04}$ | $72.23_{\pm 0.13}$ | $71.11_{\pm 0.23}$ | $69.24_{\pm 0.23}$ |  |
| GradLRP | $83.43_{\pm 0.09}$ | $81.55_{\pm 0.09}$ | $80.03_{\pm 0.06}$ | $75.12_{\pm 0.21}$ | $74.23_{\pm 0.23}$ | $72.03_{\pm 0.23}$ |  |
| Atman | $83.67_{\pm 0.05}$ | $82.11_{\pm 0.05}$ | $81.87_{\pm 0.07}$ | $76.98_{\pm 0.12}$ | $75.42_{\pm 0.12}$ | $72.43_{\pm 0.12}$ |  |
|  | Core Tokenset | $\mathbf{84.11_{\pm 0.02}}$ | $\mathbf{83.02_{\pm 0.03}}$ | $\mathbf{82.74_{\pm 0.03}}$ | $\mathbf{77.87_{\pm 0.06}}$ | $\mathbf{76.63_{\pm 0.11}}$ | $\mathbf{73.63_{\pm 0.11}}$ |

Evaluation Metrics. In all incremental setups, we report the corresponding metrics averaged over all the tasks. We report averaged accuracy for image classification and VQA. However, we note that we do not train VQA as a classification task. Instead, we open-endedly generate answers in natural language. Consequently, an answer is counted as correct if the generated text is the same as the ground-truth label. For image captioning, we report BLEU-4 (Papineni et al., ) and ROUGE (Lin, ), which measure the similarity between the model-generated text and the reference text.

### 4.4 Sequential Image Classification

In our sequential classification task, we specifically evaluate the informativeness of our memory buffer in preserving the old information by comparing two variants of coreset strategies with four ways of selecting core tokens. Tab. 1 compares the methods as a function of the stored proportion of the dataset. Here, we contrast core sets that select a subset of data points with pure extraction of core tokens that select a subset of tokens for all data points. These are then compared to core tokensets, that are based on the conjunction of the best-performing coreset and core token strategy. As a reference, the model achieves a top accuracy of 85.4% when we sequentially train it on all accumulated data of every time step, i.e. data gets added into a growing dataset over time.

Figure: Figure 5: Comparison of core tokenset selection techniques for sequential image classification. Methods vary through feature attribution technique, yet all demonstrate improvements over a traditional GradMatch-based core set.
Refer to caption: x6.png

We first notice a significant drop in performance with a gradual decline in retention rates when data is randomly selected. Here, the more sophisticated coreset selection techniques offer substantial improvement, with GradMatch being the slightly better approach. Turning to the specific approaches to identify influential tokens, perturbing attention scores, as in Atman, stands out as the best-performing core token selection mechanism. GradLRP follows closely behind, whereas GradCam and Rollout fall short. Both GradCam and GradLRP by themselves outperform the coreset strategies, reinforcing our findings of earlier Fig. 4. More importantly, our core tokenset, based on the conjunction of the best-performing GradMatch and Atman, yields improvements of several percentage points in accuracy over any of the other methods. We emphasize this difference through matching color coding, where we highlight the core tokenset performance that matches or even surpasses the corresponding GradMatch accuracy. The observable trend is that core tokensets yield similar performance at greatly reduced memory cost. This is most visible when 1 % of the data is retained, where the core tokenset performs similarly to a ten times larger core set.

To demonstrate that this obtained advantage is consistent, we combine GradMatch with all four core token selection mechanisms to form core tokensets at a common dataset retention rate of 40 %. We show the respective evolution of the accuracy as tasks get learned sequentially in Fig. 5. Here, it can be seen that the Atman (yellow, triangle) and GradLRP (green, x) curves reasonably approach the upper bound on the full dataset. However, it is particular noteworthy that any core token selection mechanism, when combined into a core tokenset with GradMatch, improves performance over the traditional core set approach (red, dashed).

### 4.5 Open-Ended Visual Questioning Answering

**Table 2: Obtained final accuracy in sequential VQA for different subset selection strategies as a function of retained data percentage. Table in analogy to Tab. 1. Color coding again highlights the best-performing coreset and core tokensets. Similar to image classification, core tokensets perform comparably or even better than a much larger sized core set in VQA tasks.**
|  | Retention rates: Visual Question Answering |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | Methods | 70% | 50% | 30% | 20% | 10% | 1% |
| Coreset | Random | $77.02_{\pm 0.11}$ | $74.86_{\pm 0.07}$ | $71.23_{\pm 0.04}$ | $69.88_{\pm 0.25}$ | $67.23_{\pm 0.33}$ | $66.03_{\pm 0.34}$ |
| CRAIG | $78.15_{\pm 0.04}$ | $76.93_{\pm 0.07}$ | $74.67_{\pm 0.07}$ | $73.56_{\pm 0.05}$ | $71.63_{\pm 0.12}$ | $70.54_{\pm 0.12}$ |  |
| GradMatch | $78.17_{\pm 0.04}$ | $77.03_{\pm 0.04}$ | $75.03_{\pm 0.03}$ | $73.93_{\pm 0.06}$ | $71.77_{\pm 0.10}$ | $70.62_{\pm 0.11}$ |  |
| Core Token | Gradcam | $77.04_{\pm 0.11}$ | $75.16_{\pm 0.12}$ | $71.83_{\pm 0.04}$ | $70.45_{\pm 0.25}$ | $68.93_{\pm 0.33}$ | $67.66_{\pm 0.34}$ |
| Rollout | $77.14_{\pm 0.11}$ | $75.56_{\pm 0.07}$ | $73.73_{\pm 0.04}$ | $72.98_{\pm 0.25}$ | $70.33_{\pm 0.33}$ | $68.88_{\pm 0.21}$ |  |
| Atman | $77.16_{\pm 0.05}$ | $75.93_{\pm 0.05}$ | $74.15_{\pm 0.04}$ | $73.29_{\pm 0.11}$ | $71.05_{\pm 0.06}$ | $70.46_{\pm 0.11}$ |  |
| GradLRP | $78.45_{\pm 0.09}$ | $77.63_{\pm 0.05}$ | $75.43_{\pm 0.08}$ | $74.30_{\pm 0.08}$ | $72.43_{\pm 0.09}$ | $71.02_{\pm 0.14}$ |  |
|  | Core Tokenset | $\mathbf{78.70_{\pm 0.03}}$ | $\mathbf{78.01_{\pm 0.02}}$ | $\mathbf{75.99_{\pm 0.02}}$ | $\mathbf{75.32_{\pm 0.03}}$ | $\mathbf{73.35_{\pm 0.05}}$ | $\mathbf{71.98_{\pm 0.06}}$ |

We now move on to a larger-scale, multi-modal setup, where we finetune BLIP over 2 million incremental VQA pairs.
In Tab. 2, we report results over the considered selection strategies at different retention rates.
While GradMatch remains the best coreset selection strategy, GradLRP now takes the lead over ATMAN for identification of core tokens. Respectively, our VQA core tokenset combines GradMatch and GradLRP.
Again, core tokensets consistently outperform all other methods across all retention rates.
Similar to our image classification table, to offer better visualization, we have color-coded specific cells of coreset and core tokensets to highlight their comparable performances at contrasting retention rates. Again core tokensets can be observed to either perform much better or be significantly more memory efficient. For instance, should we wish to achieve a performance of at least 75 %, we would have to resort to a GradMatch-based core set that extracts a 30 % subset of the dataset. In contrast, core tokens already surpass our example performance criterion when retaining only 20% of the data. Once more, this effect gets amplified as we store less data, up to an astonishing performance at 1% stored data that outperforms a ten times larger core set. Consequently, the findings of our VQA experiments are consistent with those observed image classification.

### 4.6 Image Captioning

Finally, we conduct experiments on sequential image captioning tasks, comparing core tokensets (CTS) based on the various selection strategies at an aggressive retention rate of $10\%$. We have chosen this low retention rate as it already demonstrates results that are reasonably close to training on the full dataset, making it obsolete to investigate higher percentages. Instead, we report both BLEU-4 and ROUGE scores as a function of tasks over time in Fig. 6.
Again, we report GradMatch as the favorable coreset selection strategy and combine it with different core token selection strategies. In full consistency with all prior findings, all CTS variants outperform the traditional coreset, whereas the GradLRP-based CTS takes the lead and is once more closely followed by Atman. The ordering of the methods is the same for both BLEU and ROUGE scores, with both demonstrating a marginal drop in performance when only 10% of the data is stored with a CTS.

## 5 Discussion

We have thoroughly evaluated core tokensets across three different sequential tasks. Despite the different nature of these tasks, our empirical findings provide consistent insights.
The first crucial insight lies in the efficacy when comparing retention of data subsets, i.e. traditional coresets, vs. core tokens, i.e. storing the relevant subset of tokens of each data point. If these methods were to be viewed as separate competitors, then it appears to be safer to reside on the token level. Our perhaps obvious hypothesis here is that intuitively, one loses less information when throwing away an informative token, in contrast to throwing away an entire data point. As an example, if the memory size is chosen to be e.g. 10 %, it is more likely that a high amount of relevant information is still present in the top 10 % tokens of each data point, in contrast to fully throwing away 90 % of the data instances (as is done in a traditional core set). This should be particularly true if the dataset features little redundancy and every data point carries some important information.
Our second crucial insight is that naturally selection of most important data points and most relevant core tokens for each of these points should go hand in hand. We have demonstrated this through the high effectiveness and respective memory size gain in our core tokensets. Here, we hypothesize that the large obtained improvement in performance vs memory size is a result of the cascaded nature of selection. As an example, consider a scenario where we are allowed a memory equivalent to 1% size of the data. For a traditional core set, this implies discarding 99 % of all data instances. However, for a core tokenset, we can actually extract 10 % of the most meaningful data points and store only 10 % of their most relevant tokens (assuming all data points have equivalent dimensions, as is typically the case in benchmark data sets). If this respective 10 % carry the most relevant information, it is clear why such a 1 % sized core tokensets performs comparably to a 10 % coreset. This fact has consistently been observed throughout the various experiments in our paper.

Finally, this leads us to discuss the limitations of our work and its prospective future. The first limitation is shared with the majority of core set methods. It is a fact that in the present form, the data retention rate (or memory buffer size) must be chosen in advance unless an additional optimization problem is to be involved. Second, we have deliberately made the choice to treat the identification of important data points and their most informative tokens as two chained steps. This choice was motivated by our desire to show the generality of the core tokenset principle, and respectively to benchmark a plethora of conceivable selection strategies. It could thus be shown that all core tokenset strategies were beneficial in direct comparison to traditional core sets. However, some of the investigated strategies are inherently amenable to direct combination into a single selection algorithm. In fact, our empirically best-performing combination of GradMatch + GradLRP both rely on the gradient signal. As such, it is conceivable that a joint gradient-based selection strategy can be formulated. Although the computation cost of an additional backward pass is manageable, this would reduce two computations into a single step. More importantly, it opens up the avenue for future work to derive core tokenset guarantees and bounds for epsilon. We view this as a promising future direction, along with further experimentation in other domains.

## 6 Conclusion

Figure: Figure 6: Incremental learning on image caption generation tasks. The left and right panels respectively report the BLEU-4 and ROUGE score for different memory construction methods based on 10% of the data, as we finetune BLIP on five mutually exclusive MSCOCO tasks.
Refer to caption: x7.png

We have introduced core tokensets for data summarization tailored to the unique architectural properties of transformers. Building on the notion of coresets, we have demonstrated that each data sample can be sufficiently summarized with only a subset of core tokens. Consequently, we have seen the applicability of feature attribution scores in determining the relevance of each input token on the target task. Our empirical investigation in three distinct scenarios has demonstrated that core tokens are a cost-effective way to effectively preserve the stability of a sequentially trained model. With respect to future work, we envision the development of single-stage core tokenset selection strategies, where the relevant set of samples and their informative tokens are identified concurrently.

## 7 Acknowledgements

We gratefully acknowledge the support by the Hessian Ministry of Higher Education, Research, Science and the Arts (HMWK; project “The Third Wave of AI”), the hessian.AISC Service Center (funded by the Federal Ministry of Education and Research, BMBF, grant No 01IS22091), the State of Hesse Project collaborative center “High-Performance Computing for Computational Engineering Sciences (NHR4CES)” as part of the NHR Program, and German Research Center for AI (DFKI).

## Appendix A Appendix

### A.1 Details of attribution strategies

In this section, we detail the different selection strategies that ultimately influence the informativeness of the core tokensets. Our code is available at [https://github.com/paulsubarna/Core-Tokenset.git](https://github.com/paulsubarna/Core-Tokenset.git)

GradCam: Inspired by the idea proposed in the context of convolutional networks (Selvaraju et al., ), we implement a gradient-based feature attribution map for transformers. In particular, we only consider the last layer of the transformer right before the classification head to compute the gradients of the attention heads. The corresponding feature map will obtain a shape of $R^{T\times D}$ where T denotes the number of the tokens and D is the embedding dimension. As a note, GradCam is purely a class-specific approach, where we only consider the gradients with respect to the [CLS] token and set the rest of the elements in the first dimension to zero.

Rollout: Unlike Gradcam, this strategy is purely attention-based ($A$). The feature relevance map S is usually determined by multiplying the attention maps of all the blocks ($b\in B$) across the transformer layers (Abnar & Zuidema, ). It is thereby:

$$ $S={A^{(1)}}\cdot{A^{(2)}}\cdot{A^{(3)}}\cdot{A^{(B)}}$ (6) $$

GradLRP: GradLRP is the second gradient-based approach that amends some of GradCam’s limitations. As the name suggests, it combines the gradients of the individual attention maps with the layer-wise propagation score calculated from the target token to the input sample. Given a transformer model with B blocks, we first calculate the attention map ($A^{b}$) for each block ($b\in B$) comprising h attention heads. We then consider the Hadamard product of the gradients of the attention map ($\nabla A^{b}$) and the layer-wise relevance score ($L_{R}$) (Bach et al., ) concerning a target class. The final attribution map $\bar{A^{b}}$ is achieved by calculating the mean ($E_{h}$) of the product across h attention heads in addition to an identity matrix to account for skip connections in transformers.
The final influence matrix $S_{T\times T}$ for a set of tokens T is then defined by multiplying all the attention head scores, where each row consists of the relevance score of each token compared to the other token.

$$ $\displaystyle\bar{A^{b}}=\textit{I}+E_{h}(\nabla A^{b}\odot L_{R});$ $\displaystyle S_{(T\times T)}=\bar{A^{(1)}}\cdot\bar{A^{(2)}}\cdot\bar{A^{(3)} }\cdot\bar{A^{(B)}}$ (7) $$

Atman: This approach follows a different route, where the relevance of a token is determined by leveraging the perturbation technique.
In particular, we perturb the pre-softmax attention score $H$ ($\epsilon R^{h\times t\times d}$) for each token by a factor $f$ and determine their influence over the final target loss. A subtle advantage over its gradient counterpart is that perturbation-based approaches only require forward passes without calculating or storing gradients. Across all heads h and the transformer blocks, we can compute the modified pre-softmax attention scores $H_{h}$ as:

$$ $\displaystyle\tilde{H_{h,*,*}}=H_{h,*,*}\odot((\textbf{1}-f)+f(\textbf{1}-f^{t }_{k,*})\hskip 5.0pt,where\hskip 5.0ptf^{t}_{k,*}=\begin{cases}s_{t,k}&if\, \eta\leq s_{t,k}\leq 1\[4.0pt] 0&\text{otherwise,}\end{cases}$ (8) $$

Here, 1 denotes the matrix containing only ones $[1]^{t\times t}$ whereas the $s_{t,k}$ denotes the cosine similarity matrix for the T tokens. Consistent across all the heads, we manipulate the attention scores of token t by a factor of f. Due to the nature of the image sample and the correlation between a number of patches, we also manipulate the scores of the tokens, which are correlated with the token t. For that, we compute the similarity matrix consisting of the similarity scores for each token compared to other tokens and consequently select column t to perturb individual tokens. We compute the difference between the loss function with the perturbed token and the unchanged token to determine the token relevance.

The highest $I$ score contributes to the largest deviation in the loss function, highlighting the most relevant token.

$$ $\displaystyle\textit{I}^{target}_{t}\approx\mathcal{L}^{target}(z,\theta_{-z_{ t}})-\mathcal{L}^{target}(z,\theta)$ (9) $$

Here, $\theta$ denotes the set of model parameters whereas the $\theta_{-z_{t}}$ gives the weight parameters with the perturbed token. Ultimately, we consider the row of the most relevant token from the cosine similarity matrix to construct our core tokenset.

Figure: Figure 7: Visualization of the attention maps constructed with the help of different feature attribution techniques. To provide intuition, we gradually reduce the retention rates (R) for the tokens to be retained from a sample.
Refer to caption: extracted/5909814/compare.png

### A.2 Visualization of Attention map

In this subsection, we visualize the token relevance map computed using different feature attribution techniques to select the core tokens. To provide better intuition, we gradually reduce the retention rate from 60% to 20% and visualize which of the core token selection strategies were able to preserve the target object in consideration. Referring to Fig 7, we observe that random selection, as speculated, fails to capture the relevant information within a sample with the gradual decline in the retention rate. Out of all feature attribution techniques, we notice that GradLRP successfully identifies the target object in consideration, in this case, the elephant, even at a lower retention rate of 20%. Perturbation techniques perform well to preserve the core information but also capture a few background patches owing to the closely related patches present in image samples. In the case of Rollout, the closest to the GradLRP approach, we observe a similar trend in terms of establishing a token relevance map. Lastly, Gradcam seems to offer only a marginal improvement over random selection.

### A.3 Training and Dataset Details

Sequential image classification:
In this particular task, we have initialized our image transformer with a Vit-B/16 (Wightman, ) model pretrained on ImageNet21k. To mimic a sequential learning task, we have created a sequence of 5 sub-tasks, where each sub-task consists of instances from 20 random ImageNet classes. We then fine-tune our models on each sub-task for 40 epochs with a mini-batch size of 128 using Adam as an optimizer with $\beta 1$ = 0.9, $\beta 2$ = 0.999. At the end of each sub-task, we report the model’s accuracy on the current task and the previously encountered sub-tasks.

Sequential multimodal training: We have empirically evaluated our proposed approach on two distinct tasks: visual-question answering and image captioning. In the context of this work, we have explored the base model of BLIP, with VIT-B/16 being the image encoder (Li et al., ) pre-trained on 14M images, including two human-annotated datasets (COCO and Visual Genome), and three web datasets (Conceptual Captions, Conceptual 12M, SBU captions). We trained on 8 Nvidia-A100 GPU nodes.

*Visual-question answering (VQA):* To formulate a sequential learning task, we incrementally fine-tune our pre-trained BLIP in the order: VQA-v2 (Antol et al., ) $\rightarrow$ CLEVR (Johnson et al., ) $\rightarrow$ VG (Antol et al., ). Each sub-task is trained for 20 epochs with a mini-batch size of 32 and Adam as our optimizer with a weight decay of $0.05$. The learning rate is warmed up to 3e-4. Additionally, we have considered input images with random crops at a resolution of $480\times 480$. After each sub-task, we populate our memory using one of the core token selection strategies. We treat BLIP as a generative model to predict answers for a given input image and its corresponding question. Finally, we compare the predicted and target answers and report the scores as our evaluation metric.

*Image captioning:* In the case of an incremental image captioning task, we have segmented MSCOCO into a sequence of five sub-tasks based on the object class types (book, backpack, car, truck, and bottle). Much like the VQA task, we have fine-tuned the model for 20 epochs with Adam as the optimizer. Here, we have considered random crops of images with a resolution of $384\times 384$.

Figure: Figure 8: Incremental learning for VQA. Matrices show accuracy (%) of a pre-trained Image-to-Text model (BLIP (Li et al., )) trained sequentially on three datasets VQA-v2 (Antol et al., ), CLEVR (Johnson et al., ), and VG (Krishna et al., ). Experiments are conducted with a 50% retention rate.
Refer to caption: x9.png

### A.4 Additional Results

#### A.4.1 Visual Question Answering

To complement the main body, we report the plasticity and stability of the vision-language model BLIP while being trained sequentially on our VQA task, as reported in Fig. 8.
For each scenario, a task versus task confusion matrix is shown. The diagonal from the top left to the lower right represents the evaluation performance on a task when it is trained. Respectively, the upper right-hand triangle shows forward transfer, i.e. when the model is evaluated on an unseen task after being trained on a specific prior dataset. Finally, the lower left triangle quantifies backward transfer, where the model is re-evaluated on an older dataset after being trained on a new dataset.

Not surprisingly, all methods show similarly limited generalization capabilities to unseen tasks, as evident from the upper right triangle. Intuitively, any technique to store a memory of the past, whether core sets or core tokensets, does not affect this generalization capability. The observation primarily underpins that the chosen tasks and pre-trained model are meaningfully picked for continual learning.

Naturally, the lower triangle is most relevant to evaluating core tokenset selection, as it indicates forgetting between tasks. Here, cumulative training serves as an upper bound. On the contrary, finetuning without replay suffers from catastrophic forgetting, thus marking the lower bound. We can observe that all feature attribution methods improve upon random core token selection. However, a well-picked selection strategy significantly reduces forgetting. For example, when using our core tokenset based on GradLRP, we achieve over 75% accuracy on VQA after three tasks. This is roughly 95 % of the originally achieved accuracy when training the task (79.8 %). In direct comparison, GradCam ends up at 69 %, barely more than the performance of random selection at 68%.

#### A.4.2 Sequential Image Classification

To complement the main body, we further show the evolution across tasks of different feature attribution techniques for core token selection, namely GradLRP, Atman, GradCam, and Rollout. The retention rate of the tokens is fixed at 40%. In Fig. 9, the line in black represents the model’s cumulative training performance, achieving an accuracy of 85.4%. Upon storing random tokens, we observe a visible decline in performance, with the model only achieving 75.5%. Using feature attribution approaches in determining the relevance of tokens certainly aids the model in preserving their old information. Here, identifying core tokens with the help of Atman has delivered the best results. However, a gradient-based approach such as Grad-LRP only offers a marginal performance degradation of 1.8% in accuracy compared to the reported accuracy of 81.87% for Atman. The baseline approaches in the form of GradCam and Rollout are observed to have a gradual decline in performance with a deviation of 6% and 4% in accuracy, respectively. Ultimately, all techniques improve upon random selection.

Figure: Figure 9: Comparison of core token selection techniques for sequential image classification. Methods vary through the feature attribution technique, yet all demonstrate improvements over a random selection-based core set. In this case, ATMAN is the best approach to identifying core tokens.
Refer to caption: x17.png

## Peer Reviews

confidence: 2
contribution: 2
initial_rating: 5
presentation: 3
questions: See weaknesses.
soundness: 2
strengths: 1. I do not know of another paper that explores the effect of storing a subset of tokens for replay in incremental learning
2. The diversity of tasks in the experiments is good- many incremental learning papers just evaluate on one task
3. Using a subset of tokens could also benefit efficiency of replay methods.
summary: This paper explores the incremental learning task using transformers.  The authors focus on improving the efficacy of replay methods, where they argue for storing key tokens rather than entire images.  They evaluate performance on image classification, VQA, and captioning tasks, where they improve performance over other coreset methods.
weaknesses: 1. Identifying a subset of tokens that does as well as the whole sample has been explored in prior work.  In particular, there are token pruning/merging methods (e.g., [A,B]) as well as methods used to for faster training (e.g., [C]).  The authors don't discuss or compare to these methods (I only gave examples, but there are many papers on this topic that should be included in the discussion).  As such, one could see this paper as simply a new application of a known technique.

2. The authors do not compare to the state-of-the-art, but rather restrict their comparisons to closely related papers.  As such, it isn't clear how the proposed approach compares.  The authors should consider more recent methods as well as those from the broader literature for their comparisons (e.g., [D,E]).

3. It would be interesting to see how the proposed method works on a more diverse set of datasets.  While the diversity of tasks was appreciated, they are typically limited to a single dataset (and ImageNet is also restricted to a subset of categories.  A more thorough evaluation like those in the related work would improve the paper and provide additional insight into how well the proposed approach works (e..g,, [F]).

[A] DynamicViT: Efficient Vision Transformers with Dynamic Token Sparsification. NeurIPS 2021

[B] Beyond Attentive Tokens: Incorporating Token Importance and Diversity for Efficient Vision Transformers. CVPR 2023

[C] Masked Autoencoders Are Scalable Vision Learners. CVPR 2022

[D] Adaptformer: Adapting vision transformers for scalable visual recognition. NeurIPS 2022

[E] InfLoRA: Interference-Free Low-Rank Adaptation for Continual Learning. CVPR 2024

[F] CLR: Channel-wise Lightweight Reprogramming for Continual Learning. ICCV 2023

---

confidence: 3
contribution: 2
initial_rating: 6
presentation: 3
questions: - Have you compared the latency of core tokensets with other data selection methods?
soundness: 3
strengths: - **Novel Concept**: The concept of core tokensets, which select the most informative tokens within informative data points, represents a novel and efficient way to summarize datasets for sequential training of transformers.

- **Solid Performance**: Core tokensets demonstrate comparable effectiveness to other data selection methods (e.g., Coreset, Core Token) while substantially reducing memory usage.

- **Versatility**: Core tokensets was shown effective on multiple different vision and language tasks inlcuding image classification, visual question answering, and image captioning

- **Presentation**: The paper is clearly written and easy to follow.
summary: The paper introduces the concept of core tokensets for data-efficient sequential training of transformers, demonstrating improved performance and reduced memory usage in various vision and language tasks, including image classification, visual question answering, and image captioning.
weaknesses: While core tokensets significantly reduce memory usage, their two-step approach—first selecting informative data points and then identifying key tokens within those points—may introduce more latency in dataset summarization compared to single-step methods (e.g., Coreset, Core Token).

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: I want to see how the authors define the "discriminative tokens". More mathematical reasoning should be provided.
soundness: 3
strengths: The proposed method is with practical value, which could be applied to lots of applications.
summary: The paper proposes a new way to extract core tokenset. Overall, the paper is well written. My comments are as below:
1. I can see that the tasks used in the paper are generally easy task with 90%+ accuracies. I'm wondering the performance of the proposed method on more difficult tasks.
2. I want to see more visualized results. Will that be possible to show the extracted token, and corresponding image patches?
3. I think the work can be related to model explainability, will the authors cite some related works and explain the model?
4. How to define the relevancy among tokens? I still think the proposed method lack theoretical basis; also, I want to see more model training details.
weaknesses: As can be found in the summary.

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 4
questions: What is the theoretical bounds or guarantees on the performance of core tokensets?
soundness: 4
strengths: - The paper introduces the concept of core tokensets, that selects the most informative tokens from important data samples.
- The authors extensively evaluate their approach across multiple sequential learning tasks, including image classification, visual question answering, and image captioning.
- The paper explores various strategies for selecting important tokens, including Grad-Cam, Rollout, GradLRP, and Atman, providing a thorough comparison.
- I like this paper's straightforward writing style, as it provides detailed explanations of existing methods and comprehensive results, rather than over-emphasizing a supposedly novel method.
summary: This paper introduces a novel concept of core tokensets, which selects only the most informative / important tokens from training samples as replay data for continual learning.
Previous works also study how to select more important samples for memory efficiency, but they do not operate at the token level.
This work further enhances this idea with a two-step selection process. First, they select important training samples with coreset selection methods (like GradMatch). Then, they identify and retain only the most relevant tokens from those selected samples using methods like Grad-Cam, Grad-LRP, and Atman.
To make transformers amenable to such partial inputs, this paper also employs random token dropping during training.
In summary, core tokensets provide an advanced way to sub-select training data at the token level, leveraging the properties of transformer architectures to enable highly efficient data replay for continual learning.
weaknesses: - The proposed token-based core tokensets are specifically designed for transformer models, which are widely used today. But this idea may have limited applicability to inspire other fields.
- Although this paper presents detailed results, I think its main drawback is the lack of theoretical findings, which makes the work silghtly looks like an experimental report. As shown in Table 1  and Table 2, the best results for Core Tokenset are obtained by combining the top Coreset selection and Core Token selection methods. However, the performance differences between all these approaches are small. This gives the impression that the paper simply stating, "A is good, B is good, so A+B is better." However, how to know which one is better? To improve the paper, I suggest conducting more theoretical studies to explain the selection process.

Meta-review: This paper studies the identification of a subset of tokens that can maintain the performance of vision transformers for tasks such as image classification, visual question answering, and image captioning. The reviewers acknowledged the strengths of the paper, including its novelty and the diverse verification across three distinct tasks. However, they also highlighted several significant weaknesses.

Following the rebuttal, several concerns remain:

* Comparison and relationship to existing works: While the authors provided a brief discussion, it did not persuade the reviewers.
* Evaluation on more challenging tasks: The authors’ response did not sufficiently address this concern and failed to convince the reviewers.
* Inadequate performance: Although results on another dataset were included, the overall performance remains unsatisfactory.
* Furthermore, two reviewers raised concerns regarding the absence of theoretical analysis.

Ultimately, two reviewers lean toward rejecting the paper, following the rebuttal discussion with the authors. Given that some unresolved concerns are significant and remain unaddressed, the AC recommends not accepting this submission at this stage.

Decision: Reject