Efficient Ensembles Improve Training Data Attribution

## Abstract

Abstract Training data attribution (TDA) methods aim to quantify the influence of individual training data points on the model predictions, with broad applications in data-centric AI, such as mislabel detection, data selection, and copyright compensation. However, existing methods in this field, which can be categorized as retraining-based and gradient-based , have struggled with the trade-off between computational efficiency and attribution efficacy. Retraining-based methods can accurately attribute complex non-convex models but are computationally prohibitive, while gradient-based methods are efficient but often fail for non-convex models. Recent research has shown that augmenting gradient-based methods with ensembles of multiple independently trained models can achieve significantly better attribution efficacy. However, this approach remains impractical for very large-scale applications. In this work, we discover that expensive, fully independent training is unnecessary for ensembling the gradient-based methods, and we propose two efficient ensemble strategies, Dropout Ensemble and LoRA Ensemble , alternative to naive independent ensemble. These strategies significantly reduce training time (up to 80%), serving time (up to 60%), and space cost (up to 80%) while maintaining similar attribution efficacy to the naive independent ensemble. Our extensive experimental results demonstrate that the proposed strategies are effective across multiple TDA methods on diverse datasets and models, including generative settings, significantly advancing the Pareto frontier of TDA methods with better computational efficiency and attribution efficacy.

## 1 Introduction

Training data plays an increasingly crucial role in modern artificial intelligence (AI) models (Kaplan et al., ). Consequently, data-centric AI emerges as a vital paradigm, emphasizing the collection, curation, and understanding of training data. *Training Data Attribution* (TDA) is a family of methods that assess the influence of each training sample on a model’s output. Numerous TDA methods have been developed and applied to a wide range of data-centric AI applications, such as mislabel detection (Koh and Liang, ), data selection (Engstrom et al., ), and copyright compensation (Deng and Ma, ), thereby gaining increasing popularity.

However, accurately attributing the training data influence on very large-scale AI applications remains an open challenge. Existing TDA methods can be generally categorized into two groups: *retraining-based methods* and *gradient-based methods* (Hammoudeh and Lowd, ).
Retraining-based methods involve the systematic retraining of the model with and without specific training samples to observe changes in the model’s output (Ghorbani and Zou, ; Jia et al., ; Feldman and Zhang, ; Ilyas et al., ; Wang and Jia, ). Such methods often require thousands of model retraining, sometimes even growing with the size of the training data, to achieve satisfactory performance, which makes them infeasible for moderately large models.
Gradient-based methods, on the other hand, estimate the influence by tracking the gradients of data samples (Koh and Liang, ; Yeh et al., ; Pruthi et al., ). These methods are typically computationally more efficient as they do not require the training of multiple models. But empirically they can be brittle in handling complex non-convex models (Basu et al., ; Bae et al., ) and be sensitive to the randomness associated with model initialization and training dynamics (Søgaard et al., ).

Recent studies have shown that gradient-based TDA methods can be significantly improved by ensembling tens of models independently trained with different random seeds, leading to state-of-the-art attribution efficacy on modern neural network models (Søgaard et al., ; Park et al., ).
Aggregating these independently trained models helps to mitigate the randomness introduced by training dynamics, such as random initializations and stochastic optimization. However, despite its impressive performance, scaling such a naive independent ensemble approach further for very large models remains challenging due to the significant computational costs associated with training multiple models.

In this work, we hypothesize that training models independently is unnecessary for the purpose of TDA ensemble, and we propose two efficient ensemble strategies alternative to the naive independent ensemble approach. Our first strategy, Dropout Ensemble, is motivated by dropout (Srivastava et al., ), a common deep learning module initially designed to efficiently approximate ensemble. Dropout Ensemble reduces the computational costs by replacing the independently trained models in the naive ensemble approach with multiple dropout-masked models using the same original model. Our second strategy, LoRA Ensemble, is motivated by an efficient fine-tuning technique, LoRA (Hu et al., ). Similar to Dropout Ensemble, LoRA Ensemble reduces the computational costs by replacing the independently trained models with LoRA fine-tuned models from the same original model, which is particularly suitable for generative Transformer models (Vaswani et al., ).

We evaluate the proposed Dropout Ensemble and LoRA Ensemble with extensive experiments. Our experiments span various datasets (MNIST (LeCun et al., ), CIFAR (Krizhevsky et al., ), and MAESTRO (Hawthorne et al., )), model architectures (Multi-Layer Perceptrons (MLP), Residual Neural Networks (ResNet) (He et al., ), and Transformers (Vaswani et al., )), and TDA methods (TRAK (Park et al., ), Influence Function (Koh and Liang, ), and Grad-Dot/Grad-Cos (Charpiat et al., )). Compared to the naive independent ensemble approach, Dropout Ensemble and LoRA Ensemble can significantly reduce the training time, serving time, and space costs by respectively up to 80%, 60%, and 80% while maintaining similar TDA efficacy.

We summarize the contributions of this work as follows:

- •
We demonstrate that fully independent training is not a strict requirement for effective TDA with ensembles, which opens up a promising direction for developing more efficient and effective TDA methods.
- •
We draw intriguing connections among dropout, LoRA fine-tuning, and ensemble, which leads to two novel efficient ensemble strategies for TDA: Dropout Ensemble and LoRA Ensemble.
- •
Our proposed Dropout Ensemble and LoRA Ensemble achieve significant efficiency improvement across a diverse range of machine learning models, datasets, and TDA methods, advancing the state-of-the-art of TDA.

## 2 Related Work

TDA methods quantify the influence of each training sample on the model predictions by assigning a TDA score to the sample. These methods can be categorized into retraining-based ones and gradient-based ones (Hammoudeh and Lowd, ), and our work focuses on the latter.

Retraining-based TDA methods. Retraining-based methods compute TDA scores by systematically retraining the model with and without specific training samples to quantify their influence on the model’s output. These methods are computationally expensive due to the requirement of the large amount of model retrainings. For example, Leave-One-Out (LOO) influence tuk () measures the prediction difference between the model trained on the full training dataset and models trained on subsets with only one specific sample dropped. Data Shapley (Ghorbani and Zou, ; Jia et al., ), Beta-Shapley (Kwon and Zou, ), and Data Banzhaf (Wang and Jia, ) extends the LOO idea to consider data interactions for more equitable TDA scores, but they require retraining models on all possible subsets of the training dataset. Similarly, DataModels (Ilyas et al., ) tries to learn the model predictions when the model is trained on each subset of the training dataset, which requires a nontrivial amount of model retraining. While, in practice, sampling or approximation will be used to reduce the number of model retrainings, these methods typically still require thousands of or more retrainings to achieve satisfactory attribution efficacy. In summary, the high demand for retraining makes these TDA methods computationally inefficient and limits their practical applicability to even moderately large models.

Gradient-based TDA methods. Gradient-based methods are another group of TDA methods that usually provide closed-form TDA scores using gradients. Since the seminal work of influence function by Koh and Liang (), gradient-based methods have become increasingly popular due to their scalability. The influence function (Koh and Liang, ) and subsequent studies (Guo et al., ; Barshan et al., ; Schioppa et al., ; Kwon et al., ) obtain TDA scores by approximating the effect of upweighting a training sample on the loss function. Moreover, Representer Point Selection (Yeh et al., ) decomposes the pre-activation of a neural network as a linear combination of training samples. TracIn (Pruthi et al., ) traces the loss changes on the test points during the training process. TRAK (Park et al., ) uses the neural tangent kernel with random projection to assess influence. These gradient-based methods significantly reduced the computational cost compared to retraining-based methods. The downside is that they typically rely on the convexity assumption and Taylor approximation to calculate TDA scores. These requirements lead to performance degradation on non-convex neural networks and sensitivity to the randomness inherent in model initialization and training.

Ensembling for gradient-based TDA methods.
Recent studies have shown the effectiveness of ensembling for improving TDA scores computed with gradient-based methods Søgaard et al. (); Park et al. (), which mitigates their typical issues associated with non-convexity and sensitivity to randomness. Ensembling normally applies the TDA method to many independently trained models. Either averaging the final TDA scores Søgaard et al. () or aggregating some intermediate terms for score calculation Park et al. (). Besides independently trained models, Park et al. () suggest that model checkpoints at different stages of a single training can be used for ensembling as well. All these ensembling methods, though effective, also require a non-trivial amount of ensembles to perform well. Empirical studies show that their TDA performance suffers significantly when ensemble size is limited (Park et al., ). Consequently, the ensemble size, and thus the cost associated with each ensemble, poses a significant barrier to the effective use of ensembling in current TDA methods.

Figure: Figure 1: Dropout Ensemble consists of two steps: (1) train $I$ models ($\{\Theta^{(i)}\}_{i=1}^{I}$) independently; (2) get $D$ dropout-masked models ($\{f^{(d)}_{\Theta^{(i)}}\}_{d=1}^{D}$) for each $i=1,\ldots,I$.
Refer to caption: extracted/5624099/images/method-dropout.png

## 3 Method

Following our hypothesis that independently trained models are unnecessary for ensembling TDA methods, we propose efficient ensemble strategies alternative to the naive independent ensemble.

### 3.1 Preliminaries

We start by formalizing the TDA problem and the naive independent ensemble method for TDA.

The TDA problem. We have a training set $\mathcal{S}=\{x_{1},\ldots,x_{n}\}$ where each $x_{i}\in\mathcal{X}_{\text{train}}$, a test set $\mathcal{T}=\{x_{1},\ldots,x_{m}\}$ where each $x_{i}\in\mathcal{X}_{\text{test}}$, and a trained model output function $f_{\Theta}$ that is parameterized by $\Theta$. Here $\mathcal{X}_{\text{train}}$ and $\mathcal{X}_{\text{test}}$ are the space of the training and test data respectively. We consider both supervised learning and generative modeling settings. For the supervised learning setting, $\mathcal{X}_{\text{train}}$ and $\mathcal{X}_{\text{test}}$ are typically identical, and each element of them corresponds to a data point with both the feature and label. For the generative modeling setting, $\mathcal{X}_{\text{train}}$ refers to the space of training data (e.g., text sequence segments for autoregressive language models) while $\mathcal{X}_{\text{test}}$ refers to the space of model generation. For the model output function $f_{\Theta}$, typically we will use the model learned from the training set $\mathcal{S}$ (i.e., the model parameters will be chosen as $\Theta^{*}=\operatornamewithlimits{argmin}_{\Theta}\sum_{x_{i}\in\mathcal{S}}
\mathcal{L}(x_{i};f_{\Theta})$ for some loss function $\mathcal{L}$). However, this is not always the case in practice (Pruthi et al., ). For a training set $\mathcal{S}$ and any test sample $x\in\mathcal{T}$, a TDA method $\tau$ derives the TDA scores $\tau(x,\mathcal{S};f_{\Theta})\in\mathbb{R}^{n}$ to quantify the influence of each training data point in $\mathcal{S}$ on the model learned from $\mathcal{S}$. More specifically, the $i$-th element, $\tau(x,\mathcal{S};f_{\Theta})_{i}\in\mathbb{R}$, is a real-valued score indicating the importance of $x_{i}$ on the model output on the test sample $x$. In the supervised classification setting, the “model output on $x$” usually refers to the loss, (log-)likelihood, or logit for the model predicting the correct class of $x$ (Koh and Liang, ; Park et al., ); in the generative setting, it typically refers to the (log-)likelihood for the model generating $x$ (Deng and Ma, ).

The naive independent ensemble method for TDA.
To mitigate the randomness led by the training dynamics of non-convex deep learning models, the naive independent ensemble method first trains a set of $I$ independent models, $\{\Theta^{(i)}\}_{i=1}^{I}$, and then derives ensembled TDA scores $\tau_{\text{ens}}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})\in\mathbb{R}^{n}$ based on the set of models.

The ensembled TDA scores could be simply obtained by averaging over the TDA scores for individual models, i.e.,

$$ $\tau_{\text{ens}}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})=\frac{1}{I} \sum_{i=1}^{I}\tau(x,\mathcal{S};f_{\Theta^{(i)}}).$ (1) $$

They could also come from more sophisticated aggregation over the individual models. For example, the TRAK method (Park et al., ) works as the following:

$$ $\tau_{\text{TRAK}}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})=\left(\frac{1 }{I}\sum_{i=1}^{I}\mathbf{Q}_{f_{\Theta^{(i)}}}\right)\left(\frac{1}{I}\sum_{i =1}^{I}\phi_{f_{\Theta^{(i)}}}\left(\Phi_{f_{\Theta^{(i)}}}^{\top}\Phi_{f_{ \Theta^{(i)}}}\right)^{-1}\Phi_{f_{\Theta^{(i)}}}^{\top}\right),$ (2) $$

where $\Theta^{(i)}$ are parameters of models independently trained on the training data; $\mathbf{Q}_{f_{\Theta^{(i)}}}$ is a diagonal matrix with each diagonal element corresponding to the “one minus correct-class probability” of a training data point under model $\Theta^{(i)}$; $\phi_{f_{\Theta^{(i)}}}$ is the vector gradient of $f_{\Theta^{(i)}}(x)$ with respect to $\Theta^{(i)}$; and $\Phi_{f_{\Theta^{(i)}}}$ is the matrix of the vector gradients of $f_{\Theta^{(i)}}(x_{j})$ stacked over the training samples $x_{j}\in S$.(^1^11Some details of the exact TRAK implementation are omitted here.)

### 3.2 Computational costs of TDA methods

Figure: Figure 2: LoRA Ensemble consists of two steps: (1) train $I$ models ($\{\Theta^{(i)}\}_{i=1}^{I}$) independently; (2) get $L$ LoRA fine-tuned models ($\{\Theta_{\text{LoRA}}^{(i,l)}\}_{l=1}^{L}$) for each $i=1,\ldots,I$.
Refer to caption: extracted/5624099/images/method-lora.png

While recent research has shown that ensembling gradient-based TDA methods can achieve decent attribution efficacy with tens of indepedently trained models (as opposed to hundreds or even thousands of model retraining in retraining-based TDA methods) (Park et al., ), it is still impractical for very large-scale or edge-device applications due to the increased time and space costs. To better quantify the time and space costs associated with TDA methods, we categorize the costs into three parts: training time cost, serving time cost, and storage cost. We provide a detailed explanation for these costs as follows:

- •
Training time cost: This refers to the computational time incurred by processing and training models to be used by TDA ensembles. This is the major computational challenge for ensembling TDA methods.
- •
Serving time cost: This refers to the remaining computational time to deploy TDA ensembles after model training. Typically, ensembling gradient-based TDA methods derives different TDA scores using multiple trained models and then aggregates them. The serving time cost will include all computational costs incurred during this process.
- •
Space cost: This refers to the parameters of the trained models that are stored by TDA ensembles. These model parameters are required to run forward and backward passes on top of the models for TDA score calculation. The space costs are generally proportional to the model size.

### 3.3 Dropout Ensemble

General methodology.
Dropout, a common module used in many modern deep learning models, is initially designed as an efficient approximation of ensemble (Srivastava et al., ). Motivated by this idea, we propose a simple, efficient ensemble strategy, Dropout Ensemble, for TDA methods. Instead of performing the TDA ensemble over a large number of independently trained models, the proposed method utilizes multiple dropout masks on the same model to perform the TDA ensemble.

In practice, Dropout Ensemble consists of two steps as illustrated in Figure 1. In the first step, we train $I$ independent models, $\{\Theta^{(i)}\}_{i=1}^{I}$, as shown by the green arrows in Figure 1. Next, as shown by the blue arrows in Figure 1, for each model $\Theta^{(i)},i\in\left\{1,\ldots I\right\}$, we obtain $D$ variants of the model with different dropout masks, which are denoted as $\{f_{\Theta^{(i)}}^{(d)}\}_{d=1}^{D}$. For any TDA method, Dropout Ensemble calculates the ensembled TDA scores through $\tau_{\text{ens}}(x,\mathcal{S};\{f_{\Theta^{(i)}}^{(d)}\}_{1\leq i\leq I,1
\leq d\leq D})$.

In comparison to the naive independent ensemble method, Dropout Ensemble can significantly reduce the training time and space costs. As we will show in Section 4.2, this method allows us to replace the expensive independently trained models with dropout-masked models that incur no additional training cost or model parameters.

TDA-method-specific optimization.
It is possible to further optimize the proposed ensemble strategy when applying it to a particular TDA method. For example, we develop a variant of Dropout Ensemble tailored for the TRAK method to reduce the serving time cost of Dropout Ensemble. Recall that in Eq. (2), the quantities $Q$’s only involve the forward pass of the models on the training data, while $\phi$’s and $\Phi$’s require the backward pass on the training data. We find that, perhaps a bit surprisingly, if we only use the dropout-masked models to calculate $Q$’s while using the original models to calculate $\phi$’s and $\Phi$’s, we can get similar attribution efficacy. Concretely, directly applying Dropout Ensemble on TRAK leads to

$$ $\tau_{\text{ens}}\left(x,\mathcal{S};\{f_{\Theta^{(i)}}^{(d)}\}_{\begin{ subarray}{c}1\leq i\leq I\\ 1\leq d\leq D\end{subarray}}\right)=\left(\frac{1}{I\cdot D}\sum_{i=1}^{I}\sum _{d=1}^{D}\mathbf{Q}_{f^{(d)}_{\Theta^{(i)}}}\right)\left(\frac{1}{I\cdot D} \sum_{i=1}^{I}\sum_{d=1}^{D}\phi_{f^{(d)}_{\Theta^{(i)}}}\left(\Phi_{f^{(d)}_{ \Theta^{(i)}}}^{\top}\Phi_{f^{(d)}_{\Theta^{(i)}}}\right)^{-1}\Phi_{f^{(d)}_{ \Theta^{(i)}}}^{\top}\right),$ $$

while in the optimized version, we have

$$ $\tau_{\text{ens}}\left(x,\mathcal{S};\{f_{\Theta^{(i)}}^{(d)}\}_{\begin{ subarray}{c}1\leq i\leq I\\ 1\leq d\leq D\end{subarray}},\{f_{\Theta^{(i)}}\}_{1\leq i\leq I}\right)=\left (\frac{1}{I\cdot D}\sum_{i=1}^{I}\sum_{d=1}^{D}\mathbf{Q}_{f^{(d)}_{\Theta^{(i )}}}\right)\left(\frac{1}{I}\sum_{i=1}^{I}\phi_{f_{\Theta^{(i)}}}\left(\Phi_{f _{\Theta^{(i)}}}^{\top}\Phi_{f_{\Theta^{(i)}}}\right)^{-1}\Phi_{f_{\Theta^{(i) }}}^{\top}\right).$ $$

In this case, we only need to evaluate the forward pass on the dropout-masked models and reduce the serving time cost by avoiding the backward pass. We call this variant of our method as Dropout Ensemble (fowrad-only).

### 3.4 LoRA Ensemble

For large-scale generative models, especially Transformer models (Vaswani et al., ), LoRA adapters have shown great success for efficiently fine-tuning the models (Hu et al., ). Our second efficient ensemble strategy, LoRA Ensemble, is motivated by the LoRA techniques. In particular, we propose to replace the independently trained models in the naive ensemble method with LoRA fine-tuned models.

Similar to Dropout Ensemble, LoRA Ensemble also consists of two steps as illustrated in Figure 2. The first step trains $I$ independent models, $\{\Theta^{(i)}\}_{i=1}^{I}$ ( green arrows in Figure 2), while the second step further trains $L$ LoRA fine-tuned models, $\{\Theta_{\text{LoRA}}^{(i,l)}\}_{l=1}^{L}$, for each $\Theta^{(i)}$, $i\in\left\{1,\ldots,I\right\}$ ( brown arrows in Figure 2).

In comparison to Dropout Ensemble, LoRA Ensemble will introduce a small amount of additional training time cost and model parameters for LoRA fine-tuning. However, using LoRA adapters can reduce the serving time cost of TDA compared to either dropout-masked models in Dropout Ensemble or independent models in the naive method. This leads to a unique advantage for LoRA Ensemble if the serving time cost is critical among the computational costs.

## 4 Experiments

In this section, we empirically evaluate the efficiency and efficacy of the proposed Dropout Ensemble and LoRA Ensemble.

### 4.1 Experimental setup

We conduct extensive experiments on a wide range of settings.

TDA methods. We apply the proposed methods to various gradient-based TDA methods, including influence function (IF) (Koh and Liang, ), Grad-Dot/Grad-Cos (Charpiat et al., ), and TRAK (Park et al., ). The detailed descriptions and implementations of these algorithms are provided in Appendix A.

Datasets and models.
We consider models with different architectures trained on diverse datasets: (1) a three-layer MLP classifier trained on the MNIST-10 dataset (LeCun et al., ), (2) a three-layer MLP classifer and a ResNet-9 classifier (He et al., ) trained on the CIFAR-2 dataset (a two-class subset of the CIFAR-10 dataset (Krizhevsky et al., )), and (3) a Music Transformer (Huang et al., ) trained on the MAESTRO dataset (Hawthorne et al., ). Notably, the former two are supervised classification settings, while the last one is a generative modeling setting. We sample 5000 training samples and 500 test samples from MNIST-10 and CIFAR-2 datasets. For MAESTRO dataset, we sample 5000 training samples and 178 generated samples. More detailed setups for each dataset and model are listed in Appendix B. MNIST-10 dataset holds CC BY-SA 3.0 license. CIFAR-10 dataset holds CC-BY 4.0 license. MAESTRO dataset holds CC BY-NC-SA 4.0 license.

Evaluation metric for TDA efficacy.
We utilize the linear datamodeling score (LDS) (Park et al., ) to evaluate the efficacy of the TDA methods augmented by different ensembling methods. Intuitively, LDS measures the rank correlation between the TDA scores among training samples and the change of model outputs by removing a subset of training samples and retraining the model from scratch. A higher LDS value corresponds to a better alignment between the TDA scores and the influence of the training samples on the model outputs, thus better TDA quality. We refer the reader to Appendix D for the exact definition of LDS.

Evaluation metrics for TDA efficiency.
As introduced in Section 3.2, we measure the TDA efficiency in terms of the training time cost, serving time cost, and space cost. For both training and serving time costs, we measure the wall-clock time on a single A40 GPU. For the space cost, although ideally one would measure it by memory usage, this can be challenging because memory usage is sensitive to the specific implementation and parallelization. Therefore, we measure the space cost by the total parameter count instead. For Dropout Ensemble, we will also use the number of independently trained models ($I$) as a measure of the training time cost and space cost, as both of the two costs are proportional to $I$ in this case. More details about the measurements are provided in Appendix E.

Figure: Figure 3: The LDS of naive independent ensemble and Dropout Ensemble with different numbers of dropout-masked passes ($D$) and independently trained models ($I$). We apply the ensemble methods to the TDA method, TRAK. There are four experiment settings: MLP classifiers trained on MNIST and CIFAR-2 (top row); ResNet9 trained on CIFAR-2 (bottom-left); and Music Transformer trained on MAESTRO (bottom-right). The $x$-axis indicates the training time cost measured by the number of independently trained models ($I$). The $y$-axis indicates the attribution efficacy measured by LDS.
Refer to caption: x1.png

Figure: Figure 4: The LDS of naive independent ensemble and Dropout Ensemble on more TDA methods, IF, Grad-Dot, and Grad-Cos. The experiments are performed on MLP classifiers trained on MNIST. The plot setup is similar as Figure 3.
Refer to caption: x2.png

Figure: Figure 5: The LDS of Dropout Ensemble and its variant Dropout Ensemble (forward-only) when applied to TRAK on different dataset and model settings. The $x$-axis indicates the serving time cost measured by the running time on a single A40 GPU. The $y$-axis indicates the attribution efficacy measured by LDS. The points in the plot correspond to different numbers of dropout masked models ($D$). The number of independently trained models ($I$) is fixed to 5.
Refer to caption: x3.png

### 4.2 Dropout Ensemble

Improvement over the training time cost.
To illustrate the improvement over training time cost comparing Dropout Ensemble to the naive ensemble, we first report the results on the TRAK method across four experiment settings.
As can be seen in Figure 3, across all four experiment settings, increasing the number of dropout-masked passes ($D$) results in significant LDS improvement for a fixed number of independently trained models ($I$). Recall that Dropout Ensemble does not incur any additional training time cost for a fixed $I$. This implies that Dropout Ensemble can significantly reduce the training time cost for achieving the same level of attribution efficacy as measured by LDS. For example, Dropout Ensemble with $I=5$ can reach higher LDS than naive independent ensemble with $I=25$ for MLP on MNIST and MLP/ResNet9 on CIFAR-2, which achieves a 80% reduction on training time cost. For Music Transformer on MAESTRO, Dropout Ensemble with $I=1$ can reach higher LDS than naive independent ensemble with $I=10$, which achieves a 90% reduction.

We find that Dropout Ensemble works similarly well for other TDA methods. In Figure 4, we report the results on IF, Grad-Dot, and Grad-Cos. We only experiment on the setting of MLP classifiers trained on MNIST, as these TDA methods do not have meaningfully good efficacy on more complex settings. Similar to the TRAK experiments, we observe that Dropout Ensemble with $I=1$ could match the LDS of naive independent ensemble with $I=10$ for IF and Grad-Dot, and match that with $I=5$ for Grad-Cos. Therefore, we expect that the proposed Dropout Ensemble can be generalized to various gradient-based TDA methods.

Improvement over the space cost.
The improvement of Dropout Ensemble over the space cost is self-evident, which can also be measured by $I$, the number of independently trained models. According to Figure 3, for example, applying Dropout Ensemble on TRAK (in comparison to naive independent ensemble) can lead to a 80% or 90% reduction in space cost for different model and dataset settings.

Dropout Ensemble (forward-only) improves the serving time cost. Figure 5 shows the results of Dropout Ensemble (forward-only), a variant of Dropout Ensemble specifically tailored for TRAK. In comparison to the vanilla Dropout Ensemble, this optimized variant can achieve comparable TDA accuracy with around 50% less serving time.

We also report additional ablation studies and results of Dropout Ensemble in Appendix F.

Figure: ((a)) Training time cost improvement.
Refer to caption: x4.png

### 4.3 LoRA Ensemble

To demonstrate the efficiency of LoRA Ensemble, we only consider TRAK Park et al. () as the main TDA method in this section since it is the most effective (in terms of LDS) among the four gradient-based TDA methods discussed in Section 4.2. We experiment LoRA Ensemble under the setting of Music Transformer on MAESTRO because this setting aligns better with large-scale real-world generative settings where LoRA adapters are more prevalent.

As shown in Figure 6, LoRA Ensemble outperforms naive independent ensemble since it can reach similar LDS as the latter with significantly less computational costs in terms of all types of measurements. For example, LoRA Ensemble with ($I=1,L=3$) achieves similar LDS as naive ensemble with $I=5$, while having reduction in training time, serving time, and total parameter count respectively for $78.4\%$, $60.5\%$, and $79.6\%$.

## 5 Conclusion

We present Dropout Ensemble and LoRA Ensemble as efficient alternatives to the naive independent ensemble approach for improving gradient-based TDA methods. The proposed strategies significantly reduce training time (up to 80%), serving time (up to 60%), and space cost (up to 80%), while maintaining similar attribution efficacy in comparison to the naive ensemble. Empirical results from our extensive experiments show that the proposed efficient ensembles can remarkably advance the Pareto frontier of TDA methods with better computational efficiency and TDA efficacy. Notably, we demonstrate the proposed methods work well on a generative modeling setting. In the future, we will utilize our methods in more real-world generative settings that were blocked by high computational costs or low effectiveness of TDA methods.

## Appendix A TDA methods

In this section, we provide details on the TDA methods we perform efficient ensembling on. Additionally, we also introduce the ensembling aggregation methods, i.e., the way to aggregate $\tau_{\text{ens}}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})$, for each method. The notation will follow Section 3.1.

#### Tracing with the Randomly-projected After Kernel (TRAK).

This is a state-of-the-art gradient-based TDA method provided by Park et al. (). It natively introduces ensembling in their definition.

$$ $\displaystyle\tau_{\text{TRAK}}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})= \left(\frac{1}{I}\sum_{i=1}^{I}\mathbf{Q}_{f_{\Theta^{(i)}}}\right)\left(\frac {1}{I}\sum_{i=1}^{I}\phi_{f_{\Theta^{(i)}}}\left(\Phi_{f_{\Theta^{(i)}}}^{\top }\Phi_{f_{\Theta^{(i)}}}\right)^{-1}\Phi_{f_{\Theta^{(i)}}}^{\top}\right),$ $$

Detailed notation description is described in Section 3.1. We use 2048 as the random projection dimension for TRAK. For each independently trained model, we train the model on half sampled training set following Park et al. ().

#### Influence functions based on the conjugate gradients (IF).

First proposed by Koh and Liang (), the definition of IF is

$$ $\displaystyle\tau_{\text{IF}}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})= \left[\frac{1}{I}\sum_{i=1}^{I}g_{f_{\Theta^{(i)}}}(x_{j})^{\top}H_{f_{\Theta^ {(i)}}}^{-1}g_{f_{\Theta^{(i)}}}(x):x_{j}\in\mathcal{S}\right],$ $$

where $g_{f_{\Theta^{(i)}}}(x)$ is the vector gradient of model output $f(x;\Theta^{(i)})$ with respect to the parameters $\Theta^{(i)}$, $H^{-1}_{f_{\Theta^{(i)}}}$ is the hessian matrix with respect to the training set, and $g_{f_{\Theta^{(i)}}}(x_{j})^{\top}$ is the vector gradient to the training sample. The product of the first two terms are an inverse-hessian-vector-product problem, we implement conjugate gradients approach to solve it.

#### Grad-Dot.

Grad-Dot is proposed by Charpiat et al. (). We simply calculate Grad-Dot multiple times on trained parameters $\Theta^{(i)},i\in\left\{1,\ldots,K\right\}$ and take the average value.

$$ $\displaystyle\tau_{Grad-Dot}(x,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})= \left[\frac{1}{I}\sum_{i=1}^{I}g_{f_{\Theta^{(i)}}}(x)^{\top}g_{f_{\Theta^{(i) }}}(x_{j}):x_{j}\in\mathcal{S}\right],$ $$

where $g_{f_{\Theta^{(i)}}}(x)^{\top}$ is the vector gradient of model output $f(x;\Theta^{(i)})$ with respect to the parameters $\Theta^{(i)}$, and $g_{f_{\Theta^{(i)}}}(x_{j})^{\top}$ is the gradient to the training sample.

#### Grad-Cos.

Similar to Grad-Dot,

$$ $\displaystyle\tau_{Grad-Cos}(z,\mathcal{S};\{f_{\Theta^{(i)}}\}_{i=1}^{I})= \left[\frac{1}{I}\sum_{i=1}^{I}\frac{g_{f_{\Theta^{(i)}}}(x)^{\top}}{\|g_{f_{ \Theta^{(i)}}}(x)\|}\frac{g_{f_{\Theta^{(i)}}}(x_{j})}{\|g_{f_{\Theta^{(i)}}}( x_{j})\|}:x_{j}\in\mathcal{S}\right],$ $$

where $g_{f_{\Theta^{(i)}}}(x)^{\top}$ is the vector gradient of model output $f(x;\Theta^{(i)})$ with respect to the parameters $\Theta^{(i)}$, and $g_{f_{\Theta^{(i)}}}(x_{j})^{\top}$ is the gradient to the training sample.

## Appendix B Detailed experiment setup

#### MLP on MNIST-10.

For the MNIST-10 (LeCun et al., ) experiment, we sampled 5000 training samples and 500 testing samples. We used a 3-layer MLP with hidden layer sizes equal to 128 and 64 and placed dropout layers after the first two linear layers with a rate of 0.1, which resulted in a total of about 0.11M parameters. We employed an SGD optimizer with learning rate 0.01, momentum 0.9, and batch size 64 to train this MLP classifier for 100 epochs.

#### MLP/ResNet-9 on CIFAR-2.

For CIFAR-2 experiment, we construct the CIFAR-2 dataset by sampling from the CIFAR-10 dataset that only include the “cat” and “dog” classes (same as the setting in Park et al. (),). To incorporate a diverse set of model architectures, we train an MLP and a CNN-based model on this dataset. We also only consider a subset of the CIFAR-2 dataset with a training size equal to 5000 and a testing size equal to 500. Firstly, we use a 3-layer MLP with hidden layer sizes equal to 120 and 84 and place dropout layers after the first two linear layers with a rate of 0.1, which results in a total of about 0.38M parameters. We employ an SGD optimizer with a learning rate of 0.01, momentum of 0.9, and batch size 64 to train this MLP classifier for 50 epochs. Additionally, we consider a standard ResNet-9 model (He et al., ) with dropout layers being placed after all convolution layers, which has roughly 4.83M trainable parameters. We train this model for 50 epochs.

#### MusicTransformer on MAESTRO.

For the MAESTRO experiment, we use the MIDI and Audio Edited for Synchronous TRacks and Organization (MAESTRO) dataset (v2.0.0) Hawthorne et al. () and construct a Music Transformer following the original setting in (Huang et al., ). Specifically, the number of layers equals to 6, the number of independent heads equal to 8, the input feature size is 512 and the dimension of the feedforward network is 1024. For data processing, we follow the basic experiment setup used by (Deng and Ma, ). To be more specific, we define a vocabulary set of size equal to 388, which includes
“NOTE ON” and “NOTE OFF” events for 128 different pitches, 100 “TIME SHIFT” events, and 32 “VELOCITY” events. The raw data is pre-processed as sequences of about 90K events. Due to computational constraints, we train a Music Transformer model on a subset of the official training set in the MAESTRO dataset with a size of 5000. For training, the batch size has been set to 64, and the model is trained by a classic seq2seq loss function. We employ an Adam optimizer with a learning rate equal to 1e-4, $\beta_{1}=0.9$ and $\beta_{2}=0.98$. We apply zero warm-up steps since the dataset size is comparably small, and we train the model for 20 epochs. For music event generation, we use 178 samples from the official testing dataset as prompts to generate music with a single event, which is used to evaluate the TDA methods.

## Appendix C Efficient ensemble setup

### C.1 Dropout Ensemble

Dropout is applied to the same layers as the model training stated in Appendix B. Dropout rate is set to 0.1 for all experiment settings.

### C.2 LoRA Ensemble

This method is only applied to MusicTransformer trained on the MAESTRO dataset. According to Section 3.4, we first train $I$ independent models on the full training dataset with 10 epochs using different model initialization, and all the other remaining settings follow Appendix B. The LoRA adapters used in this experiment all have rank $r=8$, alpha $\alpha=8$, and trainable biases. No dropouts are applied for LoRA parameters. We augment LoRA adapters to only the $W_{q}$ and $W_{v}$ matrices in the self-attention modules within all the layers of the MusicTransformer. Then, we define fine-tuning datasets for each LoRA adapter as random training data subsets with a size equal to 2500 (i.e., half of the original training dataset size). We further fine-tune each of the aforementioned $I$ independent models using $L$ different LoRA adapters for an additional 10 epochs on these random training data subsets, which results in a total of $I\cdot L$ LoRA fine-tuned models.

## Appendix D Linear datamodeling score (LDS)

Park et al. () proposed the linear datamodeling score (LDS), aiming at probing the TDA method’s ability to make counterfactual predictions based on the attribution score derived from the learned model output function $f_{\Theta}$ and the corresponding dataset to train $f_{\Theta}$. Because most TDA methods are assumed to be additive(^2^22If a TDA method is additive, then it defines an attribution score that the overall influence of a group is the sum of the individual influence in the group.), the TDA scores can be used to predict the model output function learned from a subset of training data in a summation form. Formally, the attribution-based output predictions of the model output function $f_{\Theta_{\mathcal{S}^{\prime}}}$ is defined as follows:

$$ $g_{\tau}(x,\mathcal{S}^{\prime};\mathcal{S})\triangleq\sum_{i:x_{i}\in\mathcal {S}^{\prime}}\tau(x,\mathcal{S};f_{\Theta})_{i},$ (3) $$

where $\mathcal{S}$ is the training set, $\mathcal{S}^{\prime}\subseteq\mathcal{S}$ is a subset of $\mathcal{S}$ and $f_{\Theta_{\mathcal{S}^{\prime}}}$ is the model output function with $\Theta_{\mathcal{S}^{\prime}}$ learned from $\mathcal{S}^{\prime}$. Intuitively, $g_{\tau}(x,\mathcal{S}^{\prime};\mathcal{S})$ computes the overall attribution of the subset $\mathcal{S}^{\prime}$ on example $x$, which should be a powerful indicator of the model prediction on $x$ (i.e., $f_{\Theta_{\mathcal{S}^{\prime}}}(x)$) if the TDA method works well. The linear datamodeling score (LDS) is defined to measure the predictive power of $g_{\tau}(x,\mathcal{S}^{\prime};\mathcal{S})$ and can be formalized as follows:

###### Definition D.1 (Linear datamodeling score) .

Given a training set $\mathcal{S}$, a model output function $f_{\Theta}$, and a corresponding TDA method $\tau$. Let $\{\mathcal{S}_{1},\ldots,\mathcal{S}_{m}:\mathcal{S}_{j}\subseteq\mathcal{S}\}$ be $m$ randomly sampled subsets of $\mathcal{S}$, each of size $\alpha\times n$ for some fixed $\alpha\in(0,1)$. The linear datamodeling score (LDS) of $\tau$ for a specific example $x$ is defined as

$$ $LDS(\tau,x)\triangleq\boldsymbol{\rho}(\{f_{\Theta_{\mathcal{S}_{j}}}(x):j\in[ m]\},\{g_{\tau}(x,\mathcal{S}_{j};\mathcal{S}):j\in[m]\}),$ $$

where $\boldsymbol{\rho}$ is the Spearman rank correlation (Spearman, ), $f_{\Theta_{\mathcal{S}_{j}}}$ is the model output function with $\Theta_{\mathcal{S}_{j}}$ learned from $\mathcal{S}_{j}$ and $g_{\tau}(x,\mathcal{S}_{j};\mathcal{S})$ is defined in Eq (3).

To compute LDS for our experiment settings, we use 50 models that are independently trained on random subsets with size half of the full dataset (i.e., we set $m=50$ and $\alpha=0.5$ in Definition D.1).

###### Definition D.1 (Linear datamodeling score) .

## Appendix E Wall-clock time measurements

In this paper, we use the wall-clock time on a single A40 GPU to measure the computational costs if the number of independently trained models (i.e., the value of $I$) can not precisely demonstrate the costs, e.g., the training time cost and serving time cost of LoRA Ensemble.

Here, we define several components that dominate the wall-clock time of different ensemble methods.

- •
TTrain: The time to train a model from scratch.
- •
TTrain, Base: The time to train a base model from scratch for LoRA tuning. Normally speaking, TTrain, Base $<$ TTrain.
- •
TTrain, LoRA: The time to fine-tune for one LoRA adapter.
- •
TServing: The time to calculate the TDA scores for one trained model after model training.
- •
TServing, Forward-only: The time to calculate the TDA scores for one trained models after model training with shared gradients. (will only be used by Dropout Ensemble(forward only). Normally speaking, TServing, Forward-only $<$ TServing, Forward-only.
- •
TServing, LoRA: The time to calculate the TDA scores after model training for one LoRA adapter. Normally speaking, TServing, LoRA $<$ TServing.

The total computational cost is approximated and summarized in t:

- •
Training time cost (naive independent ensemble/Dropout Ensemble/Dropout Ensemble (forward only)): $I\times$ TTrain.
- •
Training time cost (LoRA Ensemble): $I\times$ TTrain, Base + $I\times L\times$ TTrain, LoRA.
- •
Serving time cost (naive independent ensemble): $I\times$ TServing.
- •
Serving time cost (Dropout Ensemble): $I\times D\times$ TServing.
- •
Serving time cost (Dropout Ensemble (forward only)): $I\times$ TServing + $I\times(D-1)\times$ TServing, Forward-only.
- •
Serving time cost (LoRA Ensemble): $I\times L\times$ TServing, LoRA.

## Appendix F Additional experiment for Dropout Ensemble

### F.1 Ablation experiment to random projection

Here, we examine the root of the Dropout Ensemble’s performance through an ablation experiment. There are no random factors other than dropout for IF, Grad-Dot, or Grad-Cos, while there is another random factor, i.e., random projection, in TRAK. We perform $D$ dropout-masked passes with dropout enabled, i.e., “Dropout Ensemble’́ and $D$ dropout-masked passes with dropout disabled, i.e., “Only Random Projection”, in Table 1 and calculate the LDS. Random projection does contribute to the accuracy improvement, but the improvement will saturate when $D$ is large.

**Table 1: Ablating the contribution of test-time dropout. The experiment is carried out on MNIST+MLP. Note that $D$ is the number of dropout-masked passes, and $I$ is the number of independently trained models.**
|  | $D$<br>$I$ | 1 | 3 | 5 |
| --- | --- | --- | --- | --- |
| Naive Independent Ensemble | N/A | 0.122 | 0.217 | 0.275 |
| Dropout Ensemble | 10 | 0.249 | 0.399 | 0.457 |
| Only Random Projection | 0.210 | 0.335 | 0.398 |  |
| Dropout Ensemble | 25 | 0.316 | 0.458 | 0.502 |
| Only Random Projection | 0.217 | 0.351 | 0.413 |  |

### F.2 Intermediate checkpoints

Here, we show that Dropout Ensemble ensemble can also be applied to intermediate checkpoints and improve the accuracy. Park et al. () states that intermediate checkpoints with fewer epochs can be used for ensembling to reduce the training time cost. We save multiple checkpoints from different epochs of the same training process ($I=1$).

**Table 2: The TDA efficacy of Dropout Ensemble on intermediate checkpoints from different epochs of the same training process ($I=1$). Note that $D$ is the number of dropout-masked passes, and #ckpts is the number of intermediate checkpoints used.**
| Ensembling methods | $D$<br>#ckpts | 1 | 3 | 5 |
| --- | --- | --- | --- | --- |
| Naive Independent Ensemble | N/A | 0.122 | 0.170 | 0.188 |
| Dropout Ensemble | 10 | 0.249 | 0.318 | 0.342 |
| 25 | 0.316 | 0.359 | 0.373 |  |

## Appendix G Memory costs of Dropout Ensemble and LoRA Ensemble

Here we record the peak memory usage at serving time for Dropout Ensemble (Table 3) and LoRA Ensemble (Table 4) applied on TRAK algorithm. The memory of vanilla Dropout Ensemble is the same as naive independent ensemble. The meomory of Dropout Ensemble (Forward Only) is larger than vanilla Dropout Ensemble because some of the cached terms. The memory usage of LoRA Ensemble is slightly lower than naive independent ensemble because of the reduction in parameter size.

**Table 3: The peak memory usage of Dropout Ensemble and its alternative on TRAK with different numbers of dropout-masked passes ($D$) and the number of independently trained models fixed to 5 ($I=5$).**
| Datasets and Models | method variants<br>$D$ | 3 | 10 | 25 |
| --- | --- | --- | --- | --- |
| MNIST+MLP | Dropout Ensemble | 342M |  |  |
| Dropout Ensemble (Forward Only) | 636M | 1956M | 4787M |  |
| CIFAR2+MLP | Dropout Ensemble | 344M |  |  |
| Dropout Ensemble (Forward Only) | 638M | 1966M | 4797M |  |
| CIFAR2+ResNet9 | Dropout Ensemble | 477M |  |  |
| Dropout Ensemble (Forward Only) | 785M | 2087M | 4877M |  |
| MAESTRO+MusicTransformer | Dropout Ensemble | 538M |  |  |
| Dropout Ensemble (Forward Only) | 634M | 1529M | 3421M |  |

**Table 4: The peak memory usage of LoRA Ensemble and naive independent ensemble applied on TRAK for MusicTransformer trained on MAESTRO dataset. Note that $I$ represents the number of independently trained models, and $L$ is the number of LoRA adapters augmented on each model.**
| Ensembling Methods | $L$<br>$I$ | 1 | 3 | 5 | 10 |
| --- | --- | --- | --- | --- | --- |
| Naive Independent Ensemble | N/A | 431M | 538M | 538M | 538M |
| LoRA Ensemble | 3 | 404M | 404M | 404M | 404M |
| LoRA Ensemble | 10 | 404M | 404M | 404M | 404M |
| LoRA Ensemble | 25 | 404M | 404M | 404M | 404M |

## Appendix H Space costs of Dropout Ensemble and LoRA Ensemble

Here we record the parameter count to present the space cost for Dropout Ensemble (Table 5) and LoRA Ensemble (Table 6).

**Table 5: The space cost (total parameter count) of different experiment settings under different numbers of independently trained models ($I$). Note that Dropout Ensemble will not incur any additional storage cost with more dropout-masked passes (i.e., the space cost is fixed with respect to $D$).**
| $I$(w/ any $D$)<br>settings | MNIST<br>+MLP | CIFAR-2<br>+MLP | CIFAR-2<br>+ResNet-9 | MAESTRO<br>+MusicTransformer |
| --- | --- | --- | --- | --- |
| 1 | 0.11M | 0.38M | 4.83M | 13.11M |
| 3 | 0.33M | 1.14M | 14.48M | 39.35M |
| 5 | 0.55M | 1.89M | 24.13M | 65.58M |
| 10 | 1.09M | 3.79M | 48.25M | 131.16M |
| 25 | 2.73M | 9.48M | 120.63M | 327.89M |

**Table 6: The space cost (total parameter count) of MusicTransformer under different numbers of independently trained models ($I$) and different numbers of LoRA adapters ($L$). LoRA Ensemble only add marginal space cost (at most a $18.7\%$ increment for $D=25$ across all $I$) compared to naive independent ensembling.**
| $I$<br>$L$ | Naive Independent<br>ensemble ($L=0$) | 3 | 10 | 25 |
| --- | --- | --- | --- | --- |
| 1 | 13.11M | 13.41M | 14.09M | 15.57M |
| 3 | 39.35M | 40.23M | 42.29M | 46.72M |
| 5 | 65.58M | 67.05M | 70.49M | 77.87M |
| 10 | 131.76M | 134.11M | 140.99M | 155.73M |

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see weaknesses.
soundness: 3
strengths: The authors have motivated their problem well and seen the need for developing better ensembling methods based on simple techniques as opposed to naive ensembling which could be retraining or fine-tuning  models fully. They base their development on the TRAK approach which proposed ensembling after using random projections of gradients to counter the computational expense of determining attribution scores.

The authors also differentiate between training, serving and space cost. They also use some practical tricks such as in Iines 236-239 where they only use the dropout models to calculate Q values whereas their randomly projected gradients are determined based on the original models.

Improvements are seen in performances and good utility is demonstrated for the dropout case. I did not check the theory but it sounds reasonable at least in Case 1.
summary: A number of training data attribution (TDA) methods have been developed recently to quantify how training data points influence particular model predictions. However, they have a clear trade-off between computational complexity and accuracy. The authors propose to improve the accuracy of “gradient-based methods” (that are computationally efficient) to improve this trade-off. In particular, they attempt to replace naive ensembling methods with LoRA and Dropout ensembling and show results.
weaknesses: These are some comments that the authors may consider:
1. While the methods do improve performance, they do not help scale TRAK to larger models since TRAK approach has a huge storage cost. This also seems to lead the authors to test with smallish models.
2. It’s not clear how the LORA approach compares with the dropout approach. Is there any way to compare them with each other? Also the LORA has only been demonstrated for the Music Transformer model. 
3. If the authors really want to demonstrate this with large scale generative models, they should consider language transformer models (even smallish ones like 1B or so parameters). I can understand the practical infrastructure difficulties but this must be spelled out. What are the bottlenecks for a larger scale evaluation?
4. The limitations of the approach must be spelled out (increase in space cost). You can consider adding this in a dedicated section on limitations of the work.
5. Showing some qualitative examples that show the test data and attributions for the naive and the proposed ensemble methods will be useful.

Overall this seems like a simple extension to TRAK like methods so it scores a bit low on novelty, so this must be compensated by thoroughness in experimentation and presentation.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see the weakness part.
soundness: 2
strengths: 1. This paper is well-organized, with a clear and logical structure that makes it easy to follow and understand.

2. The proposed strategies are technically sound and could significantly reduce the training time and space costs compared to the naive independent ensemble method.
summary: The authors focus on improving gradient-based methods for data-centric learning. They propose two ensemble strategies as efficient alternatives to the naive independent ensemble approach. Experiments on public datasets are conducted to demonstrate the efficacy and efficiency of the proposed strategies.
weaknesses: 1. The authors proposed two strategies, DROPOUT ENSEMBLE and LORA ENSEMBLE. However, it is unclear which might perform better and their respective advantages in different scenarios.
    
2. Given that the computational time of TracIn [1] is also quite low, the comparative advantages of DROPOUT ENSEMBLE over TracIn as well as the reasons are not well stated.
    
3. The idea of LORA ENSEMBLE appears similar to GEX [2]. It could be helpful to include GEX in the related work section and discuss the differences and potential advantages of LORA ENSEMBLE.
    
4. There are no experiments provided to evaluate the proposed strategies on data-centric tasks (for example, mislabel detection). Understanding their performance in this context would be valuable.

5. There are some typos. For example,

- Line 183 on Page 4: indepedently
- Line 252 on Page 5: fowrad-only
- Legends in Fig. 4: Naive Ensmeble

```
[1] Garima Pruthi, Frederick Liu, Satyen Kale, and Mukund Sundararajan. "Estimating training data influence by tracing gradient descent." Advances in Neural Information Processing Systems 33 (2020): 19920-19930.
[2] SungYub Kim, Kyungsu Kim, and Eunho Yang. "GEX: A flexible method for approximating influence via Geometric Ensemble." Advances in Neural Information Processing Systems 36 (2024).
```

---

confidence: 3
contribution: 3
initial_rating: 8
presentation: 3
questions: On line 126-127 you state that training and test sets are identical in the supervised case. However from my experience a validation split is usually excluded from the training set. Could you clarify?

You show the trade off between performance and training time between their method and independently trained ensembles. Could you also discuss the trade offs between serving-time and performance when compared with independently trained ensembles?
soundness: 3
strengths: The method is straightforward to understand and implement since it relies primarily on the use of widely available modules (e.g. dropout). The method is flexible and can be applied across a wide variety of settings. The authors demonstrate that their method can perform attribution at a similar level to the naive independent ensemble method with far less training.
summary: It has been previously observed that combining training data attribution scores from independently trained models produces better attributions. However, training and deploying an ensemble of models can be very expensive. In this work, the authors propose the use of dropout and fine tuning (specifically through LORAs) to create ensemble members in a way that incurs far less computation at training time.

The authors demonstrate empirically that this provides an improvement in performance and training time tradeoffs on a variety of models and tasks and over a variety of training data attribution methods. They then perform a theoretical analysis of their method to identify regimes in which their method is expected to perform well.
weaknesses: If I understand the method correctly, it should generally be expected that, while training time significantly improves using this method, serving time would be more expensive. If this is the case then it should be made clearer in the paper, ideally with some quantification of this cost.

While the authors perform experiments across a variety of methods, models, tasks, and metrics, the full grid of possible evaluations is not complete. For example, a comparison between the lora based and dropout based method appears to be missing from the main body of the paper.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: While reading the paper I found it hard to reason about the relative importance of training, serving and storage costs, and I wonder if it would help to specify which setting you're targeting. For example, if it's large LMs or diffusion generate models, which costs matter most? Major LM providers are arguably more concerned about serving costs than training costs, so a discussion of your intended setting seems important. What both your methods have in common is that they reduce training and storage costs, but I'm not sure they provide a Pareto improvement in the accuracy / serving-time tradeoff.

For dropout ensembling, how important is it that the original model was trained with dropout?

For LORA ensembling, do you think you could get meaningful LDS improvements and reduced serving costs by fine-tuning only a few layers, perhaps late in the network?
soundness: 3
strengths: - The problem setting and related work is well written and easy to follow.
- The two main ideas presented here are reasonable and offer solid options to reduce training time and storage space, which is important for large-scale models. 
- For the dropout ensemble, the trick for TRAK of only using dropout masking for the $Q$ terms was a nice idea to further reduce computation/serving time (end of section 3.3). Based on the results in Figure 5, it seems to work well in practice (although I have a question about that below).
- The main results for the dropout ensemble show that it introduces helpful variability, which given enough masks can provide a similar effect to ensembling independently trained models (Figure 3). Although the TRAK alternatives (influence functions, grad-dot, grad-cos) are much worse in an absolute sense, it's nice to see that they benefit from the dropout ensemble as well (Figure 4).
- The LORA ensemble results mostly seem encouraging as well, reflecting that a little extra training cost + a few more parameters can yield large LDS improvements. I have a couple questions about these results as well, but this is enough to establish LORA ensembling as a viable approach.
- The theory is a nice addition, but perhaps a bit disconnected because the authors don't characterize the salient distributional properties in their experiment (e.g., how correlated scores are within a dropout ensemble vs between independent models).
summary: The paper is about training data attribution (TDA) and specifically gradient-based methods like influence functions and TRAK. These tend to benefit from ensembling scores across multiple models, which has the downside of requiring i) performing multiple training runs, ii) storing multiple sets of weights, and iii) performing the same computation multiple times. The authors propose two ideas to reduce these costs: 1) averaging TDA values calculated using multiple dropout-masked models, and 2) averaging scores across multiple LORA fine-tuned models. 

Both techniques offer some type of averaging effect that empirically improves the scores, similar to the standard ensembling approach, but potentially with reduced training time and storage space requirements. For the dropout idea, the authors also propose a trick to reduce computation time. The comparisons with standard ensembling are a bit mixed, but these are interesting ideas.
weaknesses: Some assorted observations from throughout the paper:

- I can't tell how the authors justify the performance improvements quoted in the abstract and later in the paper. Can they make this logic explicit in the paper? It seems unlikely they generalize across settings or apply to both ensembling methods, and I don't know if the authors are controlling for accuracy (LDS) when making these claims.

- The authors mention one baseline that they fail to compare to, which is using multiple checkpoints from a single training run. I recognize that it would be cumbersome to add at this point, and that tuning that baseline might be necessary (e.g., which epochs to use), but it would have been nice to include because it reduces training time in a similar fashion. Can you explain why it was not included?

- From the abstract and introduction, I got the impression the authors might completely eliminate the need for multiple training runs. Unfortunately this is not the case, both methods still rely on multiple independently trained models to achieve similar performance to naive ensembling. Do you think your results convincingly show that we can't get good enough LDS scores with a single training run, even with a high number of dropout masks or LORA adapters? This seems implied by the asymptoting performance as the number of dropout masks/LORA fine-tunes grows, and might merit some discussion.

- The Figure 3 results seem to reflect that for a given serving cost, dropout ensembling is worse than naive ensembling: we can see this through the first orange point vs the fourth blue point. These figures are actually somewhat deceptive because their x-axis represents the number of independently trained models, rather than serving time or FLOPs. They effectively plott accuracy vs training time, which is the most favorable comparison for this method because it squeezes performance out of each independently trained model. Figure 5 shows serving time comparisons but omits a curve for naive ensembling... I believe the authors should be more transparent about this result, for example by including all the same plots shown for LORA ensembling (even if it's only in the appendix).

- In Figure 5, it looks like 3/4 plots show something quite surprising: that for a given number of dropout masks, their serving optimization for TRAK achieves not just lower serving time but *better LDS scores*? That's surprising and might merit some discussion. What does that tell us about which parts of TRAK truly requiring ensembling, and do you have intuition for why?

- For the LORA ensemble, I don't understand how it lets you reduce serving time - how would you get around having to backprop through the network for each set of adapters? The authors mention this on line 268 with no explanation, and reduced serving time seems to be reflected in Figure 6b. This seems like an important aspect of the method to describe in the main text.

- Why are most of the experiments performed on toy datasets? Would it have been harder to use CIFAR-10 instead of CIFAR-2? I noticed there are some more realistic settings in appendix K, why aren't they included in the main text? (For the results related to dropout ensembling, these last results seem to have the same issue I mentioned above with worse LDS for equal serving time.)

- Why are there no comparisons between dropout masks and LORA ensembling? This seems important to include.

- For the theory, it would have been nice to characterize the salient distributional properties in your experiments. For example, I believe the finding that you can't get arbitrarily good LDS scores with a large number of dropout masks and a single model reflects that one of the assumptions is incorrect (the one on line 483).

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: In general, I do not find this paper too exciting. Application of Dropout and LoRA in this context is nice, but somewhat incremental from an originality standpoint in my opinion. Also since the main claim of the paper is efficiency I would have liked to see experiments on larger datasets and also with larger models, since they are considering generative tasks. Arguments in the theory section are also weak. Case 1 argument of within group covariance being smaller than individual predictor variances, although not completely justifiable, I could still buy. However, for Case 2 the within group covariance being not too much larger than covariance between individual predictors is hard to accept, since the whole point of the paper is efficiency and having a large K implies you have to build many independent models defeating the purpose. Hence, if one were using this method they would want to have a low K, which implies for Case 2 the performance of their proposed solutions could be considerably worse.

All in all the paper is reasonable, but limited in the above mentioned ways.
soundness: 2
strengths: + Easy to peruse
+ Covers related work reasonably well
+ Experimental results are promising
summary: The paper proposes ways to efficiently simulate building ensembles of models from scratch using dropout and lora for the problem of training data attribution (TDA). Through empirical studies they show the efficacy  of their approach (lower LDS for similar time) over from scratch training. The paper also provides some theoretical analysis to justify their approach in terms of lower squared error loss.
weaknesses: - Limited originality
- Small models and datasets
- Only one TDA method experimented on for LoRA
- Weak reasoning in the theoretical section to justify their approach

Meta-review: I have read all the materials of this paper including the manuscript, appendix, comments, and response. Based on collected information from all reviewers and my personal judgment, I can make the recommendation on this paper, reject. No objection from reviewers who participated in the internal discussion was raised against the reject recommendation.

**Research Question**

This paper studies the sample influence problem based on the influence functions.

**Motivation**

The authors claim that recent research has shown that augmenting gradient-based methods with ensembles of multiple independently trained models can achieve significantly better attribution efficacy (I did not find solid evidence on this point); however, such approaches are impractical for very large-scale applications.

**Philosophy**

The authors tackle the above independent training by correlated training, i.e., some variants from a single training.

**Techniques**

The authors propose two strategies, DROPOUT and LORA ensemble. I would like to point out that DROPOUT is very similar to the concurrent work [1] and LORA is similar to GEX [2]. In general, the proposed techniques are straightforward. 

**Experiments**

1.	Personally, LDS is not a proper metric for data attribution. The data attribution has no ground truth value. In such a case, a downstream task is usually employed for evaluation. For LDS, it employs multiple simulations (the original authors suggest 100-500 models; in this paper, the authors use 50 models) for correlation fitting. First, the result is not deterministic, which is highly sensitive to the selected subsets or runs. Second, it is not appropriate for large-scale applications, which is targeted by this paper. 
2.	In the confidential message to AC, I agree that the authors do not need to conduct experiments on industrial level datasets and models. The datasets used in this paper are relatively small, which are the subsets of the complete and original one. 
3.	The analysis of training time and space saving is incorrect. The authors claim that the proposed ensemble can significantly reduce the training time cost for achieving the same level of attribution efficacy. The post-evaluation analysis associated with performance does not count, since the performance cannot be obtained in advance.

**Figure**

The visualization of figures can be further improved. 

**Theoretical Analysis**

I don’t believe that every paper requires a theoretical analysis, especially if the analysis is disconnected from the proposed method—it may even detract from the paper's overall value. The current theoretical analysis is not correlated with the proposed two methods.

**Others**

1.	I suggest the authors follow high-quality papers, which has interesting and practical implications. I understand the criteria of “high-quality” vary according to different research tastes.
2.	Since two strategies are proposed in this paper, a natural question that needs to be addressed, in what conditions one is better than another. 

[1] Revisit, Extend, and Enhance Hessian-Free Influence Functions.

[2] GEX: A flexible method for approximating influence via Geometric Ensemble.

Decision: Reject