DataInf: Efficiently Estimating Data Influence in LoRA-tuned LLMs and Diffusion Models
Authors: Yongchan Kwon
Eric Wu
Kevin Wu
James Zou
Venue: ICLR 2024 poster (2024)
Keywords: Influence function
Data valuation
Primary area: general machine learning (i.e., none of the above)
TL;DR: We propose DataInf, an efficient influence calculation method that can be easily applied to LLMs and diffusion models.

Abstract: Quantifying the impact of training data points is crucial for understanding the outputs of machine learning models and for improving the transparency of the AI pipeline. The influence function is a principled and popular data attribution method, but its computational cost often makes it challenging to use. This issue becomes more pronounced in the setting of large language models and text-to-image models. In this work, we propose DataInf, an efficient influence approximation method that is practical for large-scale generative AI models. Leveraging an easy-to-compute closed-form expression, DataInf outperforms existing influence computation algorithms in terms of computational and memory efficiency. Our theoretical analysis shows that DataInf is particularly well-suited for parameter-efficient fine-tuning techniques such as LoRA. Through systematic empirical evaluations, we show that DataInf accurately approximates influence scores and is orders of magnitude faster than existing methods. In applications to RoBERTa-large, Llama-2-13B-chat, and stable-diffusion-v1.5 models, DataInf effectively identifies the most influential fine-tuning examples better than other approximate influence scores. Moreover, it can help to identify which data points are mislabeled.

Published as a conference paper at ICLR 2024
DATAINF: EFFICIENTLY ESTIMATING DATA INFLUENCE IN
LLMS AND DIFFUSION MODELS
Yongchan Kwon Eric Wu Kevin Wu & James Zou Columbia University", Stanford University
ABSTRACT
Quantifying the impact of training data points is crucial for understanding the outputs of machine learning models and for improving the transparency the AI pipeline. The influence function is a principled and popular data attribution method, but its computational cost often makes it challenging to use. This issue becomes more pronounced in the setting of large language models and text-to-image models. In this work, we propose DataInf, an efficient influence approximation method that is practical for large-scale generative AI models. Leveraging an easy-to-compute closed-form expression, DataInf outperforms existing influence computation algorithms in terms of computational and memory efficiency. Our theoretical analysis shows that DataInf is particularly well-suited for parameter- efficient fine-tuning techniques such LoRA. Through systematic empirical evaluations, we show that Datalnf accurately approximates influence scores and is orders of magnitude faster than existing methods. In applications to RoBERTa- large, Llama-2-- 1aama----3B-ohhe 1--atthhat, and identifies the most influential tine-tuning examples better than other approximate influence scores. Moreover, it can help to identify which data points are mislabeled.
1.5 models, DataInf effectively
INTRODUCTION
Modern large language models (LLMs) and text-to-image models have demonstrated remarkable
abilities in generating human-like texts and photorealistic images, leading to diverse real-world
applications such as translation, dialogue systems, and image editing (Brown al. 2020 Rombach
et al. 2022 Jiao et al. 2023). Nevertheless, even state-of titthhe-rtt models generate factually incorrect
predictions or even biased outputs (Abid al. 2021; Ouyang et al. 2022 Ferrara 2023). often as
result of issues in the training data. This highlights the need for principled and systematic methods
to quantify the impact of specific training data points. The influence function provides a rigorous framework for evaluating the impact of each training data point on model predictions (Hampel) 1974]
Cook & Weisberg 1980). Its efficacy has been demonstrated across various downstream machine learning tasks: mislabeled data detection (Koh & Liang 2017), best subset selection (Feldman &
Zhang 2020 Guo et al., 2021). model interpretation (Han et al. 2020 Aamir et al. 2023 Grosse
al. 2023), and investigation of model biases (Wang al. 2019 Kong al. (022).
While the influence function has shown promising results, its application in real-world scenarios poses practical challenges because of its expensive computational costs. Calculating the influence function requires the computation of the inverse Hessian matrix, which involves intensive computation. Previous studies have attempted to reduce this burden; however, most existing methods still require an iterative algorithm (Martens 2010: Agarwal et al. (017)). multiple eigenvalue decompositions (George al. 2018) the training of numerous models (Feldman & Zhang 2020) obtain accurate influence estimates. It has therefore been very challenging to compute the influence function for
large models such LLMs (Devlin et al. 2018 Liu et al. 2019 Touvron al. (023) and diffusion
models (Sohl-Dickstein et al. 2015 Ho et al. 2020 Rombach et al. 2022).
Our contributions We propose DataInf, computationally efficient influence approximation method that can be easily applied to large-scale machine learning models. DataInf is based on an closed-for forsedd-oomoooo expression, leading to better computational and memory complexities
"The first three authors equally contributed. Corresponding author: James Zou, staefordeesnnno...ddd.

---

Published as a conference paper at ICLR 2024
than existing state-of-the-ar art influence computation algorithms. Our approximation error analysis suggests that Datalnf is especially effective when it is applied to parameter-effiette fine-tuned models. We evaluate the practical efficacy of DataInf through three sets of experiments: approximation error analysis, mislabeled data detection, and influential data identification. Our empirical results demonstrate that Datalnf is faster and more effective in retrieving the most (or the least) influential training data points than existing algorithmss We apply DataInf to the RoBERTa, Llama-2-1 1amna-2-13B- 13B-chat, and stable-diffusio-vll. models, demonstrating that it is easily applicable LLMs and large-scale diffusion models. Python-based implementation codes are available at https: htt::/ggtttbbb. com/ yxwon0407/DataInf
PRELIMINARIES
We denote an input space and label space by N' and V. respectively. We denote a training dataset by D = {T 31) 12=1 where I; E X' and y; E y are an imput and a label of the i-th datum. We consider the empirical risk minimization framework: For loss function f y x y E. and parameter space θ, the empirical risk minimizer is defined as follows: 0 == argmin ece Di=1 L(vi, fxx))) where So : X + y a model parametrized with E O. We set [ml] == (1, ( m) for m N.
For E [n]] and vector 77, we denote a gradient of the i-th data point's 's loss with respect to by v, V,f(i, fo.:)).
2.1 INFLUENCE FUNCTION
The influence function assesses the impact of individual training data points parameter es- timation (Hampel 1974; Cook & Weisberg, 1980 Martin & Yohai 1986). It captures how fast parameter estimates change when particular data point is up-weighted. To be more spe- cific, for & E [n] and E E R. we consider the following E-weighted risk minimization problem: (=) == argmingee 1 Σi= fe fe(zz)) eb fo(xx)). When a loss function E fe(r)) is twice-differentiable and strongly convex is well-defined, and the influence of the k-th data point (IR; Mss E D on the empirical risk minimizer 8t is defined as the derivative of ((x) (E) at 0:
for all (I,y) E X' V, the empirical risk minimizer d
Ig. (0k, yk) = dB(k)
de le=u -H(((")--0 Volk.
where H(0) == V (n Ei Van der Vaart 2000).
is the Hessian of the empirical loss (Hampel 1974
In machine learning problems, the influence function Ig- (z yk) on the empirical risk minimizer 0 is extended to the influence function on a prediction loss (Koh & Liang. 2017). For a validation (val)) )
dataset D(val) = {(= (val)) Di ) the influence of (zk)y*) on the validation loss is defined as:
I(TR, yk) =
1 m7
Vol(y, (val) (r(z(ra)))))
Ie- (FR,VE).
The influence function I[ yk) provides an intuitive interpretation of how one data point affects the
validation loss. When I( y/k) ) is large positive (zesp. negative) value, the validation loss would increase (resp. decrease) as the data point (æx, y2) is up-weighted because I(rx, Vk.) is defined as gradient of the validation loss. In other words, the influence function intuitively represents whether (IT,, yk) is beneficial or detrimental to the prediction loss.
While the influence function established on a rigorous statistical framework, its computation often poses practical challenges due to the second-order gradients in (0*). Calculating the second-order gradient is computationally intensive in general, but can be achieved with the first-order gradient when the loss function is negative ligeliill function (Bartlet 1953). To elaborate, suppose fly, fo))) = - loogpp ply fo(z)) for all (I. E X' x y and E e where p(y | fo(x)) is a probability density function of (x, u) at 0. Bartlett's 's second identity implies that
E (((((,, = E VVel(,, (VolXX,
2

---

Published as a conference paper at ICLR 2024
where the expectation is over the distribution p(Y fx())). That is, the Hessian H())) can be replaced with the second moment of the first-order gradients G(#*) = n "E= Vol.Vel This yields the following formula for the influence function:
Volly (val) fo(z; (o0 G(0))ivolss
In this paper, we restrict our focus to a negative log-likelihood function to leverage a simplified form of the Hessian function. negative log-likelihood function is one of the most commonly used loss functions and many LLMs are pre-trained with the cross-entropy loss function, which is equivalent to a negative log- logeeeilioood in classification problems (Touvron et al. 2023
2.2 INFLUENCE FUNCTION FOR DEEP NEURAL NETWORK MODELS
The influence function in equation I can be computed with only the first-order gradients; however, there are practical challenges when Je is a deep neural network model (Basu et al. 2020 Bae et al. 2022). First, when the dimension of 9 exceeds the sample size n. which is common in many modern machine learning problems, G(Ø) is not invertible because the rank of G(O) is at most n. Second, the size of G(0) is too large compute, making its computation infeasible.
To address the first issue, the "damping Hessian" approach is used in which small positive number is added to diagonal elements G()) and make it positive definite (Martens 2010). As for the second issue, G(0) is replaced with its block diagonal matrix, where each block corresponds to layer of a deep neural network model. To be more specific, suppose fo can be expressed as a composition function fo( fez ....Q fe, (x) where for l E [L]. we denote vectorized notation of weights and biases the [-th layer by 0: E Rd for some di E N. Then, the [-th diagonal block of G()) can be E &o {T. and G(0) is replaced with diag(G, (8)...., ())
expressed (0) :=
(Grosse et al.
2023
Combining these approaches gives the following influence function:
Σ 1=1
Tf (Gil0") + +ala)) VoLk
(2)
where Vy == m-m1m1 Ex=
so(2; (val)) ) Ar is some positive constant, and L4 Rddd is the identity matrix of size dj. The influence function in equation 2 not only stabilizes but also simplifies the computation of the Hessian matrix, becoming the standard estimand in the literature.
Vo, (ra))
Shifting the focus of the influence function from equation | to equation makes the calculation more feasible, yet it is often costly, especially when di large. We next review one of the most widely used approximate methods called LiSSA.
Agarwal et al. (2017) proposed an iterative approach to compute the inverse Hessian vt. For V1.0 vt. LiSSA recursively computes the following equation: TıІ 1 + (1 (Gi(0)) + ) Agarwal et al. (2017) showed that when (G+(0")+ + A 3 la, in the Löwner order, the rr,j converges to (Gi(0" + Atla,) - uy as j
LiSSA
vector product (Gr(0") + Ar
increases. The influence function based LiSSA is obtained by computing - rT. Volea In essence, it uses the following approximation:
Fi. R (Gi(0") \eTa,)
In practice, it is often assumed that LiSSA converges to the inverse Hessian vector product (Gi(0") + ATTa;) vy in reasonable number of iterations. When the number of iterations finite, the computational complexity for LiSSA becomes O ndf)) operations with ((max di) memory complexity
'hee computational complexity can be further accelerated to O nd.) with improved memory com- plexity ((maxig(1) di) by leveraging the first-order gradients. These big O complexities are equal to those of the proposed method, but ours still has advantages over LiSSA as it does not require expensive iterative algorithm. In experiments, compare ours with this accelerated LiSSA algorithm.
3

---

Published as a conference paper at ICLR 2024
Several approaches, including LiSSA, have been studied to efficiently compute the influence function for deep neural network models. However, most of the existing methods require expensive iterative algorithms (Koh & Liang Schioppa al. 2022), multiple eigenvalue decomposition operations (Grosse et al. (023). or the training of a numerous number of models (Feldman & Z/hang/ 2020). Consequently, when attempting apply these methods to LLMs diffusion models, their feasibility becomes severely constrained. In response to this significant challenge, we introduce a new closed- form expression that approximates the influence function.
3 DATAINF: EFFICIENT INFLUENCE COMPUTATION
We propose Datalnf, an efficient influence computation algorithm characterized by easy-to- compute closed-form expression. DataInf has better efficiency in both computational and memory complexities than existing state-of-the-an methods. The key approximation of DataInf is to swap the order of the matrix inversion and the average calculations (Gi(8*) + -AIaa.)
as follows:
n Σ Vo.VVo. A.d.
Vol Vo. +AIaa)
(4)
n
Here, the term Vo, + AyTa,)) has closed-form expression because it is an inverse of the sum of a rank-one matrix and diagonal matrix. To be more specific, leveraging the Sherman- Morrison formula, the right-hand side of equation $ can be simplified as follows:
Vo,Vool + ATa.)
1 nd
Ta
VOLVa d + Vo. Vole
n
In short, the inverse Hessian part, the left-hand side of equation + can be approximated with closed-form expression. Based this finding, we propose DataInf that efficiently approximates the influence function as follows.
1
L + Li,5
[Datatne Vk)
L1.is
L1,
(5)
where Lt,3 == V Vo E R for all / E [L] and i.j E [n] and Lt, == of Vo E R for all I E [Z.] and E [m]. The equation provides easy-to-compute expression of IDatatnt (æk, yk). We provide a pseudo algorithm in Appendix
DataInf can be computed in O ndz) operations with (max d)) memory. In terms of computational complexity, DataInf is much faster than LiSSA, and does not require iterative operations. Moreover, Datalnf has better memory complexity than LiSSA because it does not require storing Hessian matrices. Table T compares DataInf with the exact computation of the influence function (equation 2, denoted by Exact) and LiSSA when a model is multilayer perceptron.
Approximation error analysis While the approximation in equation provides an efficient com- putation method, may exhibit significant errors because the two terms are not equal gen- eral. To this end, theoretically investigate approximation eтror incurred by equation 4 To elaborate, we set Su: := VoLVV + ATa, The I-th part of the influence function in equa- Σn
tion can be expressed uff (n Su) Va,ck. and that of the proposed method is off n El ST. Vglc. Then, the difference between these two terms is bounded by ( Ei So)) E S 2
|
VV fellg Here, we denote the spectral norm of a ma- trix A by ||A| and denote the L norm vector by ||l|l In summary, the approximation error mainly depends on the spectral norm of the difference (n Eh_ Ss) n Σi= (i.1s%)))) ST,') In the following theorem, we show that the spectral norm scales to (dd)) when the first-order gradients and D bounded.
4

---

Published as a conference paper at ICLR 2024
Table I: Comparison between Exact, LiSSA, and Datalnf. Computational and memory complexities are obtained for a multilayer perceptron model with L layers, each with an equal number of neurons. In this case, the number of parameters each layer is the same across different layers, and we denote it by D E N. Lee, d; is equal to D for all I [L]. DataInf has better efficiency than both Exact and LiSSA in terms of computational and memory complexities. Compared LiSSA, Datalnf leverages the closed-from expression presented in equation S and thus it does not require expensive iterative algorithm.
Hessian
Underlying Approximation
Computational Complexity
Memory Complexity
Method
Inversion
Exact (equation
Matrix inversion
O + D*L)
O(D2)
LiSSA
Iterative update
equation
L(nDLL)
O(D2)
DataInf (Ours)
Closed-form expression
equation
O(nDL)
O(D)
Theorem 1 (Approximation error analysis). Suppose maX Va, oo and x are bounded. Then,
the spectral norm of the difference
E St)) Si)) - -E STz is bounded by Odd))
proof is provided in Appendix B Theorem shows that the spectral norm bounded by Odd)) when (ax Vo, &i and X are bounded. This assumption is generally satisfied in practice as gradients are typically bounded and we can control Aς. One direct implication of Theorem iis that the total approximation error is bounded by 0 1=1
L d)). This bound may be pessimistic, but
the approximation error becomes more tolerable as di is small. This is why DataInf particularly well-suited for estimating the influence of data used for LoRA fine-tuning.
EXPERIMENTS
We investigate the empirical effecctivnees of DataInf through three experiments: (i) approximation analysis, (ii) mislabeled data detection, and (iii) influential data identification. These tasks designed to quantitatively assess the practical efficacy of Datalnf, and we also present qualitative examples in 3
Experimental settings For all experiments, we consider publicly available and widely used large- scale LLMs and diffusion models. We use the RoBERTa model (Liu et al. (2019) for the approximation error analysi$ and mislabeled data detection tasks, and the Llama-2-13B--a and the saabeediffusion--1... (Rombach et al. 2022) models for the influential data identification task. During training, we use Low-Rank Adaptation (LoRA), technique that significantly reduces the memory and computation required for fine-tuning large models (Hu et al. (2021). We fine-tune models by minimizing negative log-likelihood function. As for the baseline influence computation methods, we consider Li SSA with 10 iterations (Martens 2010 Koh & Liang 2017), Hessian free which
(Touvron al. 2023
computes dot product of the first-order gradients, i.e., - Σ) of Volla (Charpiat et al. 2019 Pruthi et al. 2020). and the proposed method DataInf. For all methods, we use the same damping parameter \ 0.1 (ndd) E' V Ve, e, following the literature (Grosse et al. 2023). 20233, We provide implementation details on datasets and hyperparameters in Appendix
4.1 APPROXIMATION ERROR ANALYSIS
Theorem I shows that the approximation error increases the parameter size increases. In this experiment, we empirically study how different ranks of the LoRA matrix affect the approximation error, where anticipate the approximation error increases as the rank increases. In addition, we compare the approximation ability between the three influence calculation methods Dat Inf, and Li LiSSA. For each influence method, evaluate the Pearson correlation
*Computing exact influence functions of the 1-ma-2-13B chat and dable-diffusion-v1.. 1.5 models is highly expensive. Hence, we used relatively small model, RoBERTa-large to obtain the exact influence function value presented in equation This allows systemically perform the approximation error analysis.
5

---

Published as a conference paper at ICLR 2024
GLUE GLUE-MRRC
GLUE-SST2
GLUE-WNLI
GLUE- 00P
0.6
0.35
0.6
Correlation
0.5
Correlation
0.4
Correlatonn
0.25
0.30
Correlation
0.4
0.4
0.3
Datainf
0.2
Datainn Hessian-free
Dotai
9.3
Dotain!
0.3-
Hessian-fren
0.15
Hossian free
Hesslan-free
USSSA
LISA
0.10
LISSA
0.2
LISSA
3
Rank
Rank r
Rank
Rank
Figure 1: Correlation coefficient comparison of the three influence computation methods. The correlation coefficient captures the similarity to the exact computation of the influence function (equation 2). and thus the higher the correlation coefficient, the better. The error bar indicates 95% confidence intevall based on 20 independent runs. DataInf is significantly more correlated with the exact influence values than other methods for all ranks E {1, 2, 4}, showing better approximation ability. Also, the correlation coefficient of Data Inf generally decreases as the rank increases, consistent with our theoretical analysis.
coefficient with the exact influence function presented in equation 2] The higher the correlation is, the better. We use the four binary classification GLUE datasets (Wang et al. 2018). To simulate the situation where fraction of data points noisy, consider noisy GLUE datasets by synthetically generating mislabeled training data points. We flip a binary label for 20% of randomly selected training data points. The low rank is denoted by and is selected from 21,
Results Figure 1 shows that DataTnf is significantly more correlated with the exact influence method than Hess an- free and SSA for all ranks r E {1,2244, 4). For instance, when the dataset is GLUE-MRPC and 1, the correlation coefficient of Data f is 0.64 while Hess i annnfree and LiSSA achieve 0.50 and 0.45, respectively. We observe LiSSA is highly unstable, leading to a worse correlation than Hessian free. This instability is potentially due the LiSSA's iterative updates which often make the inverse Hessian vector product fail to converge. In addition, the correlation generally decreases as the rank increases, which aligns with our finding in Theorem Its approximation error increases as the parameter size increases. Overall, Data better approximates the exact influence function values than other methods terms of correlation coefficients. This result suggests that DataInf is well-suited for fine-tuning techniques, where the number of learnable parameters is smaller.
4.2 MISLABELED DATA DETECTION
Given that mislabeled data points often negatively affect the model performance, it is anticipated that their influence value should be larger than that of clean data points-ww when they are included, then the loss is likely to increase. In this experiment, we empirically investigate the mislabeled data detection ability of the three influence computation methods well the exact influence function (equation 2). which we denote by Exact. We consider the same noisy GLUE datasets used in the approximation error analysis. Like the previous experiment, ground -trtthhtthhhhhhh annotations for mislabeled data (e.g., one for mislabeled data and zero for clean data) are used only to evaluate the quality of the influence function, not for fine-tuning and influence calculations.
As for the evaluation metric, we use the area under the curve (AUC) score between influence values and the binary annotations for mislabeled data to capture the quality of the influence function values. This AUC measures the probability that score randomly selected from class of mislabeled data is greater than that of a class of clean data. That is, an influence function likely to assign large values to mislabeled data points will have high AUC values. We measure the runtime for computing the influence function for every training data point when one NVIDIA A40 GPU processor is used. The rank of the LoRA matrix is set to be 4, but we provide additional experimental results for 1, r 2, and r = 8 in Appendix F where we find a consistent pattern.
Results Figure 2 shows that DataInf achieves significantly better detection ability than Hessian-free and S.A on all four datasets. Compared to Exact, Dat Inf presents overall

---

Published as a conference paper at ICLR 2024
GLUE-MRPC, /m4
GLUE-SST2, 0wd
GLUE WNLJ, /-4
GLUE-QOP, /m4
0.800
0.9
0.800
0.775
0.54
0.775
0.8-
0.750
0.755
0.7
0.725
0.700
Datainf
Detainf
0.50
Datain!
0.700
Datainf
0.500
9.255
Exact
USSAA
Hessian-free
0.5
0.5
Esact
Hesslan-free
LISSA
0.48-
0.46
Hessian
LISSA
Exact
0.575
0.600
0,625
Hesslan-free
USSA
10100
18mp
25m
20:00
300000
12us0
Runtime seconds)
Runtime seconds)
Runtime (in seconds)
secords)
Figure 2: Mislabeled data detection ability comparison of the four influence computation methods when the rank of LoRA matrix r is 4. The detection ability is evaluated with AUC, and the error bar indicates a 95% confidence interval based on 20 independent runs. DataIn: shows better than or comparable detection ability to Exact, and it significantly outperforms Hessi free and LiSSA on all four datasets. As for the runtime, DataInf is much faster than Exact, demonstrating the practical effectiveness of our method.
comparable results. Interestingly, we find that DataInf is sometimes better than Exact. This is potentially because Exact is not designed for detecting mislabeled data. Even correctly labeled data can have a large influence, especially when it is close to a classifier boundary, i.e., highly ambiguous data. Another potential reason that the damping parameter A can cause the degradation of Exact, but we leave rigorous analysis of this as a future research topic. In terms of runtime, DataInf shows superior computational efficiency. For instance, on the GLUE- QQP dataset, DataInf takes 13 seconds while LiSSA and Exact take 70 and 1 11279 seconds, respectively, for computing 4500 influence function values. Across the four datasets, ours is 5.5 and 1149.6 times faster than LisSA and Exact, respectively, on average. While Hessian free is shown to be the fastest method as it does not require to compute the Hessian, its performance is strictly worse than DataInf.
4.3 INFLUENTIAL DATA IDENTIFICATION
To further illustrate the usefulness of DataInf, we assess how accurately it can identify influential data points in text generation and text-to- text-to-image generation tasks. We use the Llama-2-13B-aa model (Touvron al., 2023) for the text generation task, and the stable-diffusion-v1.. 1.5 model (Rombach) et al. 2022) for the text-to-image generation task. Both models are publicly available and widely used literature.
We construct three demonstrative datasets for the text generation task: (i) Sentence transformations, (ii) Math word problems (without reasoning), and (iii) Math word problems (with reasoning). The detailed description for each task and dataset is given in Table in Appendix D Each dataset contains 10 distinct classes, with 100 total data points in each class. We partition the 100 examples into 90 training data (used for LoRA) points and 10 test data points. For text-to-image generation, consider two tasks: (i) style generation and (ii) subject generation. For the style generation task, we combine three publicly available image-text pair datasets where each dataset represents different style: cartoons (Norod78) 2023). pixel-art (Jainr3) 2023), and line sketches (Zoheb) 2023). For each style, we use 200 training image-text pairs and 50 test image-text pairs for total of 600 training data points and 150 test data points. For the subject generation task, we use the DreamBooth dataset (Ruiz et al. 2023). There are 31 different subjects and for each subject, data points are used for the training dataset and to 3 data points are used for the validation dataset. The detailed prompts are provided in Appendix [
If some training data points help minimize a test data point's loss, then their influence function value should be negative-as validation loss should decrease when the same class data point added. Based on this intuition, we utilize two evaluation metrics. First, for each test data point, we make a pseudo label for every training data point. This pseudo label is one its label is the same as the test data point's label, and zero otherwise. We then compute the AUC between the negative influence function values and the pseudo labels. Ideally, a large AUC is expected because the same class will have a negative influence value. We report the average AUC across test data points. We denote this by class detection AUC, Second, for each test data point, we compute the percentage of training points with the same class as the test example among the smallest influential training points. Here, 8 is set to
7

---

Published as a conference paper at ICLR 2024
Table 2: AUC and recall comparison of Hessi fr-f and DataTnf influential data identifi- cation tasks. LiSSA is excluded in this experiment as it often fails to converge due to its instability. The average and standard deviation of the AUC and recall across test data points are denoted by "average-tstandard deviation", and the higher, the better for both metrics. DataInf significantly outperforms Hessian-free in both metrics across 5 different tasks.
Task & Model
Method
Class detection (AUC) Class detection (Recall)
Sentence transformations
Hessian free
0.999 = 0.002
0.985 + 0.033
Llama-2-1 1aama-2-138-char
DataInf
1.000 0.000
0.997 + 0.010
Math problems (no reasoning)
Hessian-fres
0.770 = 0.174
0.258 0.388
Llama-2 2-13B-chat
DataInf
1.000 = 0.000
0.999 0.006
Math problems (with reasoning) Llama-2 2- 2-13B-chut
Hessian-free
0.772 = 0.173
0,258 +: 0.388
DataInf
1.000 = 0.001
0.996 +: 0.025
Text-to to-aaaee style generation buble-diffasioon
Ressian-
0.692 0.007
0.533 0.008
DataInf
0.820 0.005
0.687 0.006
Text to -mia subject generation grale-diffusione
Ressian-free
0,820 = 0.000
0.210 + 0.003
DataInf
0.865 = 0.000
0.315 + 0.003
be the number of training examples per class. We report the average percentage across the test data points and denote this by recall. These metrics are intended to assess how effectively each method can identify training data points that belong to the same class as a test example as more helpful than one that belongs to different class.
Results Evaluation metries for each task and model are reported in Table 2 DataIn' significantly outperforms Hessian-free on all tasks and across all metrics identifying influential data. Of note, LiSSA demonstrated significant numerical instability across all four tasks and models, which produced invalid influence values in some runs. Even after gradient rescaling, we observed that LiSSA collapses to Hessian-fae free across all tasks. We hypothesize that this instability can be attributed to the iterative nature of LiSSA and the high-dimensional nature large-scale models. Qualitative examples with test examples and the corresponding most and least influential training data points based on their absolute values are shown in Figure]
5 RELATED WORKS
Assessing the impact of individual training data points on model accuracy predictions has been widely studied in data valuation literature. One of the most widely adopted classes of data valuation methods is based on the marginal contribution, which measures the average change in model's performance when specific data point is removed from a set data points. Many standard methods belong this category including leave-one-ore and various Shapley-based methods (Ghorbani & Zou| 2019; Jia et al.) 2019: Kwon & Zoul 2022) Wang & Jia 2023 Wang et al.) 2023). addition to these methods, several alternative approaches have been proposed using reinforcement learning (Yoon et al., 2020) or out-of-bag accuracy (Kwon & Zou 2023). Unlike all aforementioned data valuation methods, the influence function is based on gradients, conveying the rigorous and intuitive notion of data values. For an extensive review of these methods, we refer the reader to Jiang et al. (2023)
When it comes to the empirical performance on downstream machine learning tasks, other non- aafluence-based data contribution methods often outperform the influence function (Park et al.) [023] Jiang et al. 2023). However, the majority of previous studies have focused on relatively small models and datasets. This limitation arises from the computational infeasibility of existing algorithms, which typically require the training of numerous models to obtain reliable data values (Sim et al.) 2022 Feldman Zhang 2020). When LLMs or diffusion models are deployed, data valuation methods that require model training are not practically applicable. While several methods capture the value of data at model initialization and do not require a training process (Nohyun et al. 2022 Wu et al. 2022). their performance is mostly examined on relatively small neural network models. The development of an efficient computational method for LLMs or diffusion models is of critical significance, and is the main contribution of this paper.
8

---

Published as a conference paper at ICLR 2024
polnts:
Sentence transformatiions (1.omy-22133))
Moet infleential:
Least influential:
Test example prompt:
lpegua is chather that parformi spasific minformatio surtenzee Rrverse Order Hards For examppo:: Langhter fills siient rcoms -- rooms, silent fills Langher
jespeaochs is chatoot perfienss
lpugeu chatbot performs on semennces: Reverze Order of Words For example: Feotbers Beot on dreams. Completion: dreams float Fenthers
specific trrafiemationn on sentences: Replace liveede wain" For coomple: Birb ding mominng melodiie -- frrdds s"ny ni nt"mn" miringtte.
reasoning
Moel iofiecntial:
Least influcatial:
Test example prompt:
Solve the following math problem. In aquarium, there sharks and dolphins. If they bought many
Salve the follwing math problets. In an equariun. theee are statia and 56 drlphins, thy bougls mare stackes, luw many sharks would be there unal? Russoar lonsl sharle 79 denwer: #1
Michast scoeed 94 points
Solve the fallowing murh problem.
firs: game, poirss the second,
97 the thind, and the founth
Completion:
Tatal
ganse: What his und pointe?
Ressoe: Zous pointe Su 97 - 73
Aeswer: 802
Moet infieential:
Test example prompt: Generate style.
Generato imagee in specific black and white line skutch style. Zahras in an open space.
Genertie as inngg is speciãie cartoo style. A woman with blonde hair is froat of her.
specifii black white line sketch
Generated images (ofter LoRA)::
Subyect
v1.3)
Most infleential::
influential:
Test example prompt: [special--oken-A]
[spesial-tukkm-A1 dog.
Ispecial tolm bowl.
Generated Imagees (after LoRAj:
Figure 3: Illustrative examples most and least influential training data points discovered using DataInf across the generation and text-to-image generation tasks performed with the Llama-2- 13B-chat and stable-diffusion--ll models. The most (resp. least) influential data point has the largest (resp. smallest) absolute influence on the example among training data points. DataInf has successfully identified the most influential data points, which exhibit a high degree of relevance to test example prompts. Conversely, the least influential data points identified by Dat ann demonstrate lower relevance. In essence, DataInf is effective at detecting influential data points.
As concurrent and independent work, Grosse et al. (2023) proposed the Figenvalue- Kronekkeer factored approximate curvature (EK-FAC)-base) algorithm that efficiently computes the influence function. While it was applied to LLMs (though not diffusions), the EK-FAC method highly depends on the network architecture, and thus its application to LoRA-tumed models is not straightforward. detailed explanation in
The implementation of EK-FAC is also not public. We provide Appendix
CONCLUSION
We propose DataInf, efficient influence computation algorithm that is well-suited for parameter- efficient fine-tuning and can deployed LLMs and large diffusion models. DataInf is effective in identifying mislabeled data points and retrieving the most and least influential training data points on model generations. DataInf orders of magnitude faster than state-of-the-an influence computation methods and is memory efficient, and thus it can be practically useful for enabling data-centric analysis of large models such as LLMs.
In the literature, there are not many quantitative evaluation metrics for the utility of influence scores. This also presents limitations for evaluating DataInf. We tried to address it by using proxies such as data points in the same class should have greater influence than data points in different class, and mislabeled points should increase test loss. Additional downstream of the utility of influence scores for generative Al is important direction of future work.

---

Published as a conference paper at ICLR 2024
REFERENCES
Aisha Aamir. Minija Tamosiunaite, and Florentin Wörgötter. Interpreting the decisions of cnns via influence functions. Frontiers in Computational Neuroscience, 17. 2023.
Abubakar Abid, Maheen Farooqi, and James Zou. Persistent anti-muslim bias in large language models. In Proceedings of the 2021 AAAI/ACM Conference on Al, Ethics, and Society, pp. 298-306, 2021.
Naman Agarwal, Brian Bullins, and Elad Hazan. Second-order stochastic optimization for machine learning in linear time. The Journal of Machine Learning Research, 18(1):4148 2017.
Francis Bach. Information theory with kernel methods. IEEE Transactions on Information Theory, 69(2):552-775, 2022.
Juhan Bae, Nathan Ng, Alston Lo, Marzyeh Ghassemi, and Roger B Grosse. If influence functions are the answer, then what is the question? Advances in Neural Information Processing Systems, 35:17953-17967, 2022.
MS Bartlett. Approximate confidence intervals. Biometrika, 40(1/2): 1953.
Samyadeep Basu, Phil Pope, and Soheil Feizi. Influence functions in deep learning are fragile. In International Conference on Learning Representations, 2020.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D) Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models few-shot learners. Advances in neural information processing systems, 33:1877-1901, 2020.
Guillaume Charpiat, Nicolas Girard, Loris Felardos, and Yuliya Tarabalka. Input similarity from the neural network perspective. Advances in Neural Information Processing Systems, 32, 2019.
R Dennis Cook and Sanford Weisberg. Characterizations of an empirical influence function for detecting inffuential cases in regression. Technometrics, 22(4):495-508 1980.
Jacob Devlin, Ming-Was Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv: vrXiv:/810.04805. 2018.
Bill Dolan and Chris Brockett. Automatically constructing corpus of sentential paraphrases. In Third International Workshop on Paraphrasing (IWP2005), 2005.
Vitaly Feldman and Chiyuan Zhang. What neural networks memorize and why: Discovering the long tail via influence estimation. Advances in Neural Information Processing Systems, 33:2881-2891, 2020.
Emilio Ferrara. Should chatgpt be biased? challenges and risks of bias in large language models. arXiv preprint (ETi::2004.03338 2023.
Thomas George, César Laurent, Xavier Bouthillier, Nicolas Ballas, and Pascal Vincent. Fast approximate natural gradient descent in a kronecker factored eigenbasis. Advances in Neural Information Processing Systems, 31, 2018.
Amirata Ghorbani and James Zou. Data shapley: Equitable valuation of data for machine learning. In International Conference on Machine Learning, pp. 2242-2251, 2019.
Roger Grosse, Juhan Bac, Cem Anil, Nelson Elhage, Alex Tamkin, Amirhossein Tajdini, Benoit Steiner, Dustin Li, Esin Durmus, Ethan Perez, et al. Studying large language model generalization with influence functions. arXiv preprint arXiv:2308.003200 2023.
Han Guo, Nazneen Rajami, Peter Hase, Mohit Bansal, and Caiming Xiong. Fastif: Scalable influence functions for efficient model interpretation and debugging. In Proceedings of the 2021 Conference on Empirical Methods Natural Language Processing, pp. 10333-10350, 2021.
Frank R Hampel. The influence curve and its role in robust estimation. Journal of the American Statistical Association, 69(346):383-333, 1974.
10

---

Published as a conference paper at ICLR 2024
Xiaochuang Han, Byron C Wallace, and Yulia Tsvetkov. Explaining black box predictions and unveiling data artifacts through influence functions. In Proceedings of the 58th Anmual Meeting of the Association for Computational Linguistics. Association for Computational Linguisties. 2020.
Jonathan Ho, Ajay Jain, and Pieter Abbeel. Denoising diffusion probabilistic models. Advances in neural information processing systems, 33:6840-688 2020.
Edward Hu, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang. Lu Wang. Weizhu Chen, et al. Lora: Low-rank adaptation of large language models. In International Conference Learning Representations, 2021.
Jainr3. jainnt//diffuuionnnb-pideeede Datasets at Hugging Face - huggingface.co. https 2023, [Accessed
/ htt.:/g......cc.cooooaaattttt/// 24-09-2023).
Ruoxi Jia, David Dao, Boxin Wang, Frances Ann Hubis, Nezihe Merve Gurel, Bo Li, Ce Zhang. Costas Spanos, and Dawn Song. Efficient task-specific data valuation for nearest neighbor algorithms. Proceedings of the VLDB Endowment, 12(11):1610-1623, 2019.
Kevin Fu Jiang, Weixin Liang, James Zou, and Yongchan Kwon. Opendataval: a unified benchmark for data valuation. 2023. URL
Wenxiang Jiao, Wenxuan Wang, Jen-tse Huang, Xing Wang, and Zhaopeng Tu. Is chatgpt good translator? a preliminary study. arXiv preprint arXiv:2301.08745. 2023.
Pang Wei Koh and Percy Liang. Understanding black predictions via influence functions. In International conference on machine learning, pp. 1894. PMLR, 2017.
Shuming Kong, Yanyan Shen, and Linpeng Huang. Resolving training biases via influence-based data relabeling. In International Conference on Learning Representations, 2022. URL https
//openreview www.:eee/tounneee www.mmiddeess
Yongchan Kwon and James Zou. Beta shapley: unified and noise-reduced data valuation framework for machine learning. In International Conference on Artificial Intelligence and Statistics, pp. 8780-8802. PMLR, 2022.
Yongchan Kwon and James Zou. Data-oob: Out-of-bag estimate as a simple and efficient data value. 2023.
Hector Levesque, Ernest Davis, and Leora Morgenstern. The winograd schema challenge. In Thirteenth international conference on the principles of knowledge representation and reasoning, 2012.
Quentin Lhoest, Albert Villanova del Moral, Yacine Jernite, Abhishek Thakur, Patrick von Platen, Suraj Patil, Julien Chaumond, Mariama Drame, Julien Plu, Lewis Tunstall, Joe Davison, Mario Šaško, Gunjan Chhablani, Bhavitvya Malik, Simon Brandeis, Teven Le Scao, Victor Sanh, Canwen Xu, Nicolas Patry, Angelina McMillan-Major, Philipp Schmid, Sylvain Gugger, Clément Delangue, Théo Matussière, Lysandre Debut, Stas Bekman, Pierric Cistac. Thibault Gochringer, Victor Mustar, François Lagunas, Alexander Rush, and Thomas Wolf. Datasets: A community library for natural language processing. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing: System Demonstrations, pp. 175-184, Online and Punta Cana, Dominican Republic, November 2021. Association for Computational Linguistics. URL https
a/aclantho howllannhooooy...moom wtgp:/11..00000..0// emn 1p demo . 21
Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining 1669,, 2019.
approach. arXiv preprint
Sourab Mangrulkar, Sylvain Gugger, Lysandre Debut, Younes Belkada, and Sayak Paul, Peft: State- of-the-art parameter-efficient fine-tuning methods. htt.pss://githuu.com//uuu ft 2022.
James Martens. Deep learning via hessian-free optimization. In Proceedings of the 27th International Conference International Conference on Machine Learning, pp. 735-742, 2010.
11

---

Published as a conference paper at ICLR 2024
R Douglas Martin and Victor J Yohai. Influence functionals for time series. The annals of Statistics, pp. 781-818, 1986.
Ki Nohyun, Hoyong Choi, and Hye Won Chung. Data valuation without training of a model. The Eleventh International Conference Learning Representations, 2022.
Norod78. Nomod///cartooon--bip--ana
Datasets Hugging Face huggingface.cov ht htsps wttp:/ooooooo..pp............
//hh:ggiinfaccccccc///attttttt/s cessed 24-09-2023).
i 2023. [Ac-
Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang. Sandhini Agarwal, Katarina Slama, Alex Ray, et al. Training language models to follow instructions with human feedback. Advances in Neural Information Processing Systems, 35: 27730-27744, 2022.
Sung Min Park, Kristian Georgiev, Andrew Ilyas, Guillaume Leclerc, and Aleksander Madry. Trak: Attributing model behavior at scale. In International Conference on Machine Learning (ICMI.), 2023.
Garima Pruthi, Frederick Liu, Satyen Kale, and Mukund Sundararajan. Estimating training data influence by tracing gradient descent. Advances in Neural Information Processing Systems, 33: 19920-19930, 2020.
Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björ Ommer. High- resolution image synthesis with latent diffusion models. In Proceedings of the IEEE/CVF confer- ence on computer vision and pattern recognition, pp. 10684-10695, 2022.
Nataniel Ruiz, Yuanzhen Li, Varun Jampani, Yael Pritch, Michael Rubinstein, and Kfir Aberman. Dreambooth: Fine tuning text-to-image diffusion models for subject-driven generation. In Proceed- ings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 22500-22510 2023.
Andrea Schioppa, Polina Zablotskaia, David Vilar, and Artem Sokolov. Scaling up influence functions. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 36, pp. 8179-81 7779-1866, 2022.
Rachael Hwee Ling Sim, Xinyi Xu, and Bryan Kian Hsiang Low. Data valuation in machine "haniing:ingrrdieent strategies, and open challenges. In Proc. IJCAI, pp. 5607-5614, 2022.
Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew Y Ng, and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference empirical methods in natural language processing, pp. 1631-1642, 2013.
Jascha Sohl-Dickstein, Eric Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. In International conference on machine learning, pp. 2256-2265. PMLR, 2015.
Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288 2023.
Aad W Van der Vaart. Asymptotic statistics, volume 3. Cambridge university press, 2000.
Alex Wang, Amanpreet Singh. Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461. 2018
Hao Wang, Berk Ustun, and Flavio Calmon. Repairing without retraining: Avoiding disparate impact with counterfactual distributions. In International Conference on Machine Learning, pp. 2018-6627.. PMLR. 2019.
Jiachen T. Wang and Ruoxi Jia. Data banzhaf: A robust data valuation framework for machine learning. Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, 206:6388-6422 2023.
12

---

Published as a conference paper at ICLR 2024
Jiachen T. Wang, Yuqing Zhu, Yu-Xiang Wang. Ruoxi Jia, and Prateek Mittal. A privacy-friendly approach to data valuation. In Shirty-seventh Conference on Neural Information Processing Systems, 2023. URL httpap///peeeeeeeee...eee///ee/a
Thomas Wolf, Lysandre Debut, Victor Sanh, Julien Chaumond, Clement Delangue, Anthony Moi, Pierric Cistac, Tim Rault, Rémi Louf, Morgan Funtowicz, et al. Transformers: State-of-the-art natural language processing. In Proceedings of the 2020 conference on empirical methods in natural language processing: system demonstrations, pp. 38 38-45, 2020.
Zhaoxuan Wu, Yao Shu, and Bryan Kian Hsiang Low. Davinz: Data valuation using deep neural networks initialization. International Conference on Machine Learning, pp. 24150-24176. PMLR, 2022.
Jinsung Yoon, Sercan Arik, and Tomas Pfister. Data valuation using reinforcement learning. In International Conference on Machine Learning, pp. 10842-10851. PMLR, 2020.
Zoheb. zoheblsketch-scene- Datasets at Hugging Face - huggingface.co. https:/
2023. [Accessed 24-09-2023].
13

---

Published as a conference paper at ICLR 2024
A PROPOSED ALGORITHM
We provide pseudo algorithm in Algorithm
Algorithm Datalnf: Efficient influence computation
Input: A training dataset D {(x1, ((d1,91)..... y1)...., (In, yn yn)}, validation dataset D(val)
{(x(va)), v1 ) ).... ..... (Ithaa)) ( )) objective function é y > I,, deep neural network for where 0 = {01..... OL} and 01 Rd for ( [L].
model fo fer Output: Influence functions {Iaatalut (01, v1), Datatnnt (In: (In:Vn)}
# Step I: Compute the first-order gradients for l [4] do for i in [n] do Compute Vo, (y.s end for
> Training data points
Compute 1 Σド Vo, (v; (v(a))) (o((a)aa))) =: un-
(val)
Validation data points
end for
Step 2: Compute the inverse Hessian-vector product
for / in [Z] do
Compute À == 0.1 x (nd)) En V fel fe():) 2t 0.
for i in [m] do
Ga - of Vo, A(vi fo(x:))/ (>r (o,
A normalizing constant
- + + (nAi) (w) au Va foxx)))
end for end for
Step 3: Compute the influence function for i in [n] do Datalit (Ikk, Mks) Eiery o? Vo Eyr. fo(k)))
end for
B PROOF THEOREM
We provide proof of Theorem below.
Proof. We set S₁:
4, Vo. AT, and 5 := n Sq.. Then, Taylor expansior gives
a
SR
Sui
(S - -5:) (IS +1 32 t)dl)
(1)
(Sn 3i)
71
n
3 (Sn - 5:) (Su - S:) -:))².
2
X
The inequality is due to the maximum eigenvalue of (tS + (1 - t)5;)= -3 is upper bounded by A for 0 < < Then, the spectral norm of this matrix is upper bounded follows:
æ 2
n Σ (S 3i) (Sn Si)
7
S
X7
Thhis Taylor expansion is presented in (Bach 2022
14

---

Published as a conference paper at ICLR 2024
2 1
|| + +||a:11))
The first inequality is due to the triangle inequality and the second inequality is from Amax (A - B) S Amax (A) Amax( for real symmetric matrices A and B. Here, (A) denotes the largest eigenvalue of a matrix A.
For all [L] and [n], since St is a semi comi-positive definite matrix, have |Still2 Amax (Sts) S
tr(Su) and | Amax I (r.).. Hence,
2 (1Swll2 + 18:1l))
2
tr (Sw) + tr tr
A
Since || Vo (S) Md. This implies that:
is upper bounded by constant, there exists constant M 0 such that tr (St.)
2
Σ (1Sull2 +1|S/11)
2f = Odd))
1
X
C EXISTING METHODS
In this section, provide three existing influence computation methods: EK-FAC and retraining- based methods.
EK-FAC To this end, suppose fo is multilayer perceptron model. For E [M]. denote the 1-th layer output by h4 == fo, .... so, and the associated pre-activated output by Gt- Then, for all [n]. we have Vo,la h4-1 (2xx) & V la where @ denotes the Kronecker product. Moreover, the Hessian for 0j is given as follows:
1
Gi(d")
(ms) @ Vi (m1-1(a))) @ gi))))
(
g:
n
The second equality is due to the mixed-product property of the Kronecker product. George et al. (2088) proposed to approximate Gi(t") with the following equation:
1 Gi(0") ~ hn
91 A Br
This approximation accurate when one of the following approximations holds:
4
VglVV 2T
Vi [n].
(6)
n
or by (x: 1 Σ h h (2)) Vi [n].
(7)
The assumptions in equation and equation 7 essentialll assume that h and V V are constant across different training data points. While there no clear intuition, the approximation leads to computationally efficient form. Specifically, we let A Q..,, AA,, Q where QA. is an orthonormal matrix and AA,-, is diagonal matrix obtained by eigenvalue decomposition. Similarly, we factorize B₁ AB, QT, Then, we have:
(Gr(0") \vTa,) (QA,, ( @ As, + +AJa,) -(QAr 8 )T,)
15

---

Published as a conference paper at ICLR 2024
That is, (Gi(0") + ApId,)= can be obtained by applying eigenvalue decomposition of A and Bi Compared to naive matrix inversion (G:(6") + A (4a)), this approximation method has computa- tional efficiency as the size of A and B, is much smaller than d,. This method is called Kronecker Factorization, also known as KFAC. George et al. (201)) showed that that using AA, & AB, can be suboptimal in approximating with diagonal matrix A where the i-th diagonal element set to be Aa = n Ej=(((QA) & QB, Ve, G A naive computation of the left-hand side requires O(d)) operations, but both KFAC and EK-FAC can be done in O(d) operations when the size of both 1 and B₁ is v vl. Hence, the total computational complexity O(E (ndd + +d ))/3)) with
[m d)) memory complexity.
EK-FAC has a computational advantage over a naive version of LiSSA, but it might not be applicable to general deep neural network models as highly depends on the model architecture- the gradient should be expressed as Vo, lA 1 (Fx) @ Vgr lu. which it might not be true for LoRA fine-tuned models or transformer- bbsed models. This method has been used in an independent and concurrent work (Grosse et al. 2023).
Retraining-basee method For M E [n]]. we denote a set of subsets with the same cardinality by ((M) {S S _ DS M). For [n], we set S(M)) {S S(M)) (xt, u:) S} and ((M (S E S(M) (I,, 1/) & S}. Note that Si,in U ((M)) S and S, n S 0 for all
i [m]. Feldman & Zhang (2200) proposed to compute the influence of data point (24, E D on
a loss value E'y' Jo- (x") as difference of model outputs.
Σ SES
fos (x'))
Σ
fos"))
((() t,in
S
SEs
where
0s == argmingge
Σ iES
folx)).
S
This retraining-based method is flexible in that any deep neural network model can be used for fo. however, it is extremely challenging compute because necessitates the training of numerous models.
D IMPLEMENTATION DETAILS
In this section, we provide implementation details on datasets, models, and loss functions we used in Section 4 Python- based implementation codes are available at httt:s://githubbco com/ vkwon0407//atalnn
D.1 APPROXIMATION ERROR ANALYSIS AND MISLABELED DATA DETECTION
Datasets We consider the four binary classification GLUE benchmarking datasets (Wang et al. 2018). Namely, the four datasets are GLUE-MARPC (Dolan Brocketi 2005 paraphrase detec- tion), GLUE-SSTE SST2 (Socher et al. 2013 sentiment analysis), GLUE- WNL (Levesque et al. 2012 inference), and GLUE-QQ! QQP cquestion-answering dataset available at HuggingFace Datasets library (i hhhest et al. 2021). Only the training dataset is used fine-tune the model, and we compute the influence individual training data points on the validation loss. For LLUE-SST2 and GLUE-QQP randomly sample 4500 (resp. 500) samples from the original training (resp. validation) datasct.
f
We used the training and validation splits of the
Model We use LoRA to fine-tune the RoBERTa-large model. 355M parameter LLM trained on the large-scale publicly available natural language datasets (Liu et al. 2019). We apply LoRA to every value matrix of the attention layers the RoBERTa-large model. We downloaded the pre-trained model from the HuggingFace Transformers library (Wolf et al. 2020). Across all fine-tuning runs,
https://quoradataa http:///aataaauuuorrooooo//sssss www.au...oooaaaa.oo
Rel leale Pase--ueste Quest inn-tiion-Pe Pairs
16

---

Published as a conference paper at ICLR 2024
use learning rate of 3 x 10 with batch size of 32 across 10 training epochs. As for the LoRA hyperparameters, the dropout rate is set to be 0.05. We choose the rank of the LoRA matrix from {1,2, 4, 8) and is always set to be The training was performed
single machine with one NVIDIA A40 GPU using the HuggingFace Peft library (Mangrulkar et al. 2022).
For the Exact method, exclude the case with one NVIDIA A40 GPU processor and the GLUE-MRPC dataset, it takes more than 18 hours when r 8. Also, we find that the LoRA with smaller can yield a similar model performance to the LoRA with r = 8. See Figure 6
compute it in reasonable time. Specifically,
Loss All GLUE benchmarking datasets used are binary classification datasets, so used negative ligeeiklioood function as a loss function. For a sequence of imput tokens x = (I1,.... 2T) and its label y, consider [yy fa()))
log ply fo(z)) where is a composition model consists of the RoBERTa-large model to convert text data into numerical embeddings, and logistic model perform classification on the embedding space. We set T = 128.
D.2
INFLUENTIAL DATA IDENTIFICTIOO
D.2.1
TEXT GENERATION
Datasets Full dataset prompts are described in Tables and
Model We use LoRA to fine-tune Jlama-2-13B-chal an LLM that has 13 billion parameters, is pre-trained on trillion tokens, and is optimized for dialogue cases (Touvron et al., 2023). We apply LoRA to every query and value matrix of the attention layer in the Llama-2-13B- Across all fine-tuning runs, we use learning rate of 10-4, LoRA hyperparameters r 8 and = 32, in 8-bit quantization, with a batch size of 64 across 25 training epochs. The training was performed on a single machine with 4 NVIDIA V100 GPUs using the HuggingFace Peft library (Mangrulkar et al. 2022).
model.
Loss We used negative log-likelihood of a generated response loss function. For sequence of input tokens x = (#1,.... IT,) and the corresponding sequence of target tokens (y1,.... yr,) suppose the -lama-2-13B generates sequence of output tokens f=()) (fe (2) 1, [0 fe(r) has the same size of T2 and is generated in an auto-regressive manner. We set Zi T22 = 512. fe(x)
T' Then, the loss function is fly, fz)) DT= log p(v:
The test accuracy for the base coon-finettnnee and fine-tuned models shown in Table We observe substantial improvements across the three tasks, with additional improvements from introducing an intermediate reasoning step to the math word problems.
Experiments
D.2.2 TEXT-TO-IMAGE GENERATION STYLE GENERATION
Datasets Figure 4 illustrates examples of images used in the text-to-image generation task. When we fine-tuned a model, a style description is added to text sequence to instruct a style. For instance, "Generate an image in a specific (custom) style. [text-data)", where (custom) ) is substituted with either "cartoon", "pixelart", or "black and white line sketch", and [text-data] is substituted with text sequence in the training dataset. We provide detailed description in Table 7
Model We also use LoRA to fine-tune stable-diffusion--11. (Rombach et al.) 2022). ). We apply
LoRA to every attention layer in the table-diffussoon-/ model. Across all fine- min-ttunngg runs, use a learning rate of 10-4, LoRA hyperparameters r =- 1 and a = 1. We fine-tune a model with batch size of 4 across 10000 training steps. The training was performed NVIDIA V100 GPUs using the HuggingFace Peft library (Mangrulkar et al. 2022
single machine with
Loss Similar to other experiments, used negative log likelihoodd of generated image a loss function. For a sequence of input tokens x = (ø)..... 22T) and the corresponding target image y, we compute negative log-likelihood E(y. (2:)) ply fo(x)). We set T 77.
17

---

Published as a conference paper at ICLR 2024
Experiment We compare generated images before and after the LoRA fine-tuning, For quantitative comparison, the baseline and fine-tuned models are evaluated by comparing the Fréchet inception distance (FID) between images in the test set with images generated using the paired texts from the test set. FID for the hefore and after fine-tuning models is shown in Table
D.2.3 TEXT-TO-IMAGE GENERATION SUBJECT GENERATION
We used the same setting with the text-to-image generation style generation task, but the rank of LoRA matrices is set to 4. We here explain the datasets.
Datasets Figure illustrates examples of images used in the text-to-image generation task. Our models use Google's Dreambooth dataset Ruiz et al. (2023). which contains 31 unique subjects in categories like backpack, dog, bowl, and sneaker. Each subject has four six total examples, and we take three from each subject as the training set, with the remaining as the validation. We add unique random string to each subject to prompt the model to produce each subject. For example, to differentiate two different dogs, we use prompts "a 5a2PZ dog" and "a POVRB dog" in the training and test set.
Table 3: Description of each task and dataset used in Section describe the full dataset prompts in Table 5
4.3
For the text generation task, we
Task
Description
Sentence transformations
The model is asked perform specific transformation sentence. different types of sentence transformations are used. aid the model learning distinct transformations, "chatbot" name identifiers that are uniquely associated with each transformation are added to the prompts. model asked to provide a direct answer to simple arithmetic word problem. Ten different types of math word problems are constructed, and random positive integers used construct unique data points.
Math problems (without reasoning)
Math problems (with rea- soning)
Using the same questions with as above (Math problems without reason- ing), the prompt includes an intermediate reasoning step before arriving the final answer.
Text-to-image style genera-
The model is asked to generate an image a given style. Three different styles of images are used in our dataset. We illustrate examples of styles Figure
tion
to-image subject gen- cration
The model is asked to generate a specific subject (c.g. a dog or candle).
We illustrate examples of styles in Figure
Table 4: Performance improvements from model fine-tuning. For the text generation tasks, evaluate the classification accuracy. For the text-to-ine text-to-image generation task, we evaluate FID.
Task
Method
Accuracy
FID
Base model
0.01
Sentence transformations
Fine-tuned model
0.35
Base model
0.07
Math problems (no reasoning)
Fine-tuned model
0.20
Base model
0.08
Math problems (with reasoning)
Fine-tuned model
0.31
Base model
243.5
Text-to-image style generation
Fine-tuned model
189.6
Base model
269.7
Text-to-image subject generation
Fine-tuned model
247.5
E ADDITIONAL EXPERIMENTAL RESULTS
Approximation error analysis. We provide an additional approximation error analysis result when data clean. Figure 5 that DataInf is correlated with the exact influence function than
18

---

Published as a conference paper at ICLR 2024
Style transfer
Subject generation
"A sports car speeding down winding road."
Subject
Reference
Generated
Images
Images
Before LoRA
Finetune datasct
Afler LoRA
Dog I
cartoon
Dog 2
pixelart
sketch
Candle
Figure 4:
Examples of images used in the text-to-image generation task, along with before and after images from the LoRA fine-tuning of the stable-diffusion--1. model.
Table 5: Description of the sentence transformations task templates. We consider 10 different types of sentence transformations. For each sentence transformation, unique identifying "chatbot" names were additionally prepended to the task prompt assist the model in training.
Sentence transformations
Example transformation of "Sunrises herald hopeful tomor- rows":
Reverse Order of Words
lomorrows, hopeful herald Sunrises
Capitalize Every Other Letter
sUnRiSeS hErAID hOpEIUl tOmOrRoWs.
Insert Number Between Every
Sunrises Iherald Thopeful Itomorrows.
Word
Replace Vowels with
S"rr"**s hdr h ***' ("m*r="ws.
Double Every Consonant
SSunrrissceess hheralld hhopeffull ttomorrow..
Capitalize Every Word
Sunrises Herald Hopeful Tomorrows.
Remove All Vowels
Snrss hrld hpfi tmrrws.
Add 'ly" To End of Each Word
Sunrisesly heraldly hopefully tomorrows.ly uie ea neu 000.
Remove Consonants
Repeat Each Word Twice
Sunrises Sunrises herald herald hopeful hopeful tomorrows. to- morrows.
Hessian-free and LiSSA methods throughout different datasets and ranks. It shows that our finding is consistent regardless of the presence of noisy data.
Mislabeled data detection task. We provide additional mislabeled data detection task results when the rank r is selected from {1,2, 8}. We exclude Exact when r = 8 because it exceeds the 12-hour computation limit for all datasets. In this case, DataInf takes less than 25 seconds. Similar to the case r = 4, DataInt shows competitive mislabeled detection performance over other methods while achieving short runtime.
19

---

Published as a conference paper at ICLR 2024
Table 6: Description of the math problem task templates. We consider 10 different types of math word problems.
Math Word Problems Remaining pizza slices
Template prompt question
Lisa ate A slices of pizza and her brother atc B slices from pizza that originally had slices. How many slices of the pizza are left? Reason: Combined slices eaten = A + B. Left C- (A B). field trip, there are B adults needed as chaperones. If C students are attending, how many adults are needed?
Chaperones needed for trip
For every A students going
Reason: Adults needed = (B * // A.
Total number after purchase
an aquarium, there are sharks and dolphins. If they bought C more sharks, how many sharks would be there in total?
Reason: Total sharks A C.
Total game points
Michael scored points the first game, B points in the second, C in the third, and D in the fourth game. What is his total points?
Reason: Total points A + B C D.
Total reading hours
Emily reads for hours each day. How many hours does she read total in B days?
Reason: Total hours read = A B.
Shirt cost after discount
shirt costs A. There's B-dollar off sale. How much does the shirt cost after the discount?
Reason: Cost after discount B.
Area of garden
rectangular garden has length meters and width of meters. What is its arca?
Reason: Arca A B.
Total savings
Jake saves A cach week, how much will he save after weeks? Reason: Total savings A * B.
Number of cupcake boxes
A bakery sells cupcakes boxes of A. If they have cupcakes, how many boxes can they fill?
Reason: Boxes filled = B // A.
Interest eamed
John invests A annual interest rate of B%. How much interest will he carn after years?
Reason: Interest (A B // 100.
Table 7: Description of the text-to-image generation task templates. Each style has 200 training image-text pairs and 150 validation image-text pairs.
Image style
Text prompt
Cartoon
Generate image in a specific cartoon style. (A text sequence of the original dataset
which describes image).
Pixel Art
Generate an image a specific pixelart style. (A text sequence the original dataset which describes image).
Sketch
Generate an image a specific black white line sketch style. {A text sequence of the original dataset which describes an image).
20

---

Published as a conference paper at ICLR 2024
GLVE-MRPC
GLUE-SST2
GLUE-QNLI
GLUE- QQP
0.30
0.33
0.23
Conelatton
0.25-
Correatioo
0.30
Cornicttion
0.30
0.25
0.25
0.20
0.15
Datain!
0.20
Datainf
0.20
Dataint
0.15
Hesstar-free
Hessian-fre
Hessian-free
Hessian-free
LISSA
0.05
USSA
LISSA
Rankr
Rank
Figure 5: Correlation coefficient comparison of the three influence computation methods when data are clean. The experimental settings are exactly the same as the one in Figure [ except for the presence of noisy data.
GLUE ONLI r-1
LLUE-MMPC, r-]
GLUE LLUE-SST2,PO r-1
GLUE QQP, r-1
0.80
0.80
0.78
0.8-
0.70
0.75
0.65
Detalnf
Datalnf
0.7
Datainf
Datain!
Hessian-free
Hessian-free
Hessian-free free
Hessian free
0.55
LISSA
0.7
LISSA
LISSA
0.65
USSA
Exact
0.8
0.5
0.50
Runtime (in seconds)
Runtime fin seconds!
Runtime (in seconds)
Runtime (in seconds)
GLUE-ONLI r=2
GLUE-MRPC, r=2
GLUE-SSTZ. rm2
GLUE-QOP. n=2
0.
0.80
0.8
0.75
AUC Hesslan-tree
AUC
Datainf
Datainf
2,770
Datainf
Hessian-tree
Hessian free
Hessian free
LISSA
LISSA
USSA
0.05
LISSA
Exact
Exact
0.5
Exact
Exact
0.60
1000
1250
1500
1200
A480
1250
1500
U
Msee
Runtime seconds)
Runttime seconds)
Runtime secondsi
Runtime seconds)
0.85
LLUEE-NLI,FAE r-8
GLUE MRPC, r=8
GLUE SST2,
GLUE QOP,
6.75
0.80
Datalnf
Hessian-free
LISSA
0.75
0.80
Hessian free
Datalinf
0.9
LiSSA
Hessian-fres
0.72
Hesslan free
6.70-
0.70-
0.70
0.66
0.65
6.50
0.60
0.5-
100
6
+
10
%
+
% seconds)
%
% seconds)
%
Runtime seconds)
seconds)
Figure 6: Mislabeled data detection task ability comparison the four influence computation methods when the rank of LoRA matrix r (top) 1, (middle) and (bottom) 8. The error bar indicates 95% confidence interval based on 20 independent runs. Similar to Figure DataInf shows superior detection ability while achieving competitive computational efficiency.
21

---

Published as a conference paper at ICLR 2024
F DATA SELECTION TASK
One desired property of data contribution methods to find representative subset that can yield high model performance when a model is trained on that subset. To assess this ability of DataInf, conduct data selection experiments. The experimental setting is exactly the same as the one used Figure Once the influence function computed, we select the top 70% most beneficial data points, retrain model from scratch with the selected subset, and evaluate the model accuracy on the holdout test dataset. We compare DataTni with Ressian: free-ree and L,i SSA methods. In addition, we consider two additional baseline methods: the random selection (denoted by Ra Random) and the entire dataset (denoted by Full). We anticipate Full should be better than Random as uses more samples.
Figure 7 shows the accuracy trajectories in the first 10 epochs. First, DataInf uniformly performs better than existing methods for most of the datasets across all training epochs. Also, it better performs than Full on most of the datasets, and we believe this is because 20% of the original datasets are mislabeled. DataIn' detects these low-quality data points, leading Full. Furthermore, another interesting observation that DataInf usually achieves the best performance in the first to three epochs, meaning that it selectively finds good subset that is representative of the training dataset and helps accelerate the model training.
better performance than
Dataset: gril
gap
mrpc
0.804
0.00
Reournty
0.0
0.0
0.2
Dusate
3.70
Mossian-fee
Mosdan--ia
2.83
0.5
US54
0.6
LSSA
030
Figure 7: Data selection ability comparison of the different influence computation methods. The experimental setting is exactly the same as the one used in Figure 2 with classification accuracy, and the error bar indicates 95% confidence interval based on 20 independent runs. DataInf significantly outperforms Hessian-fres datasets, and even better than Full except the mrpp dataset. Furthermore, Data Inf achieves the best accuracy in the first few epochs, demonstrating that a selected subset is easy to learn and representative, which helps accelerate the model training. shows the practical effectiveness of DataInf in data selection tasks, especially when fraction of the training dataset is low-quality.
The detection ability is evaluated
and LiSSA on all four
22


Reviews:
[{"review_id": "OnBbXi2Wag", "reviewer": "Reviewer_NdTy", "summary": "The paper proposes an efficient influence approximation method. The proposed method outperforms existing influence computation algorithms in terms of computational and memory efficiency.", "questions": "- Section 4.1: What is the correlation analysis result when the data points are all clean?\n\n- Section 4.2: Why does exact influence sometimes underperform the approximation methods? How does the result vary with the mislabeling ratio?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 2, "presentation": 3, "contribution": 3, "strengths": "- The paper tackles an important and timely problem of estimating data influence in a scalable manner.", "weaknesses": "- One assumption made by the paper is the first equation on page 3, which states that the expectation of hessian is equal to the expectation of the second moment of gradients. This assumption only holds true when the loss function is $-\\log P(y|f_\\theta(x))$, where $f_\\theta(x)$ denotes the output probability of network parameterized by $\\theta$. However, consider the cross entropy loss function, which is $y \\log f_\\theta(x)$. There is no discussion of how the assumption applies to common loss functions. \n\n- Theorem 1 seems a loose bound. It will be much more convincing to empirically verify the introduced by the approximation and whether the error grows in $d^2$.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "nri1vJhreK", "reviewer": "Reviewer_gXtX", "summary": "## Summary\n\n- The paper proposes a new method to calculate Influence Scores which is more computationally and memory efficient than existing techniques like (LiSSA and Hessian Free techniques like Tracin)\n- It is particularly suited for parameter-efficient fine-tuning techniques such as LoRA\n- The key approximation in DataInf is to swap the order of the matrix inversion and average calculation. They conduct experiments on approximation error analysis to study the effect of this approximation because these terms are not equal in the general case. Equation (4) in the paper.\n- To measure the efficacy of their proposed approximation, the authors conduct three sets of experiments: approximation error analysis, mislabeled data detection and influential data identification\n\t- The models used are RoBERTa model, stable-diffusion-v1.5 and LLaMA-2-13B model\n\t- DataInf is significantly more correlated with with exact influence values than other methods (LiSSA and Hessian free methods like Tracin) for all ranks. Correlation decreased with increasing rank which is why DataInf is specially suitable for LoRA models.\n\t- DataInf is better at identifying mislabeled examples\n\t- They also use DataInf to identify influential training examples for LLaMA-2-13B-chat model for text generation task and stable-diffusion-v1.5 model for text to image generation task.\n\t\t- They construct 3 datasets for text generation: (i) Sentence transformation (ii) Math word problems without reasoning (iii) Math word problems with reasoning\n\t\t- For text to image generation they construct two tasks (i) style generation (ii) subject generation\n\t\t- As metric, they report the percentage of training points with the same class as the test example among the top s influential training points. DataInf has significantly better recall and AUC scores than Hessian-free approach", "questions": "- Curious as to what is the computational and memory complexity of Hessian free methods like Tracin which are omitted from the table?\n- How did you obtain multiple training checkpoints required for techniques like tracin in your experiments? Esp for the llama model, are the checkpoints publicly released or did you do your own fine-tuning and use the fine-tuning checkpoints? Do the results for tracin improve with more checkpoints?", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The result in Figure (2) is very interesting. Sometimes DataInf is even better than the exact method !", "weaknesses": "- Do LoRA finetuning methods typically only use low ranks like 2,4,6 as used in the experiments in the paper?\n\n- The paper has rightly pointed out that there aren't many qualitative metrics for measuring the utility of influence scores. The authors try to address it through proxies. The results in Figure 2 are presented with only rank 4, what do the results look like for other rank values?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "9y6N9xzN8X", "reviewer": "Reviewer_oMqQ", "summary": "In this paper, the author propose an efficient for the influence function. Different from LoRA, the author provide another efficient way to train the large language model.", "questions": "Are there any specific model configurations where you would advise not using DataInf?", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 2, "contribution": 3, "strengths": "DataInf has superior efficiency in terms of computational and memory complexities compared to other methods such as LiSSA.\nThe method can be applied on some popular framework such as LoRA.", "weaknesses": "While DataInf is efficient, it uses an approximation that is not always equal to the exact computation. This could lead to significant errors in certain cases.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "kDKmk0ClVQ", "reviewer": "Reviewer_kkF9", "summary": "In this paper, the authors provide a new method to estimate influence functions for large-scale generative models. Their theoretical results show that their method is well suited for LoRA-based fine-tuning settings. their compare their method in terms of approximation error, mislabeled data detection, and influential data identification. They observe improvement over existing methods in influence approximation.", "questions": "There is a recent line of work that casts doubt on the usefulness of approximating influence functions. They argue that for image generation tasks, utilizing an off-the-shelf visual encoder can be more helpful in identifying influential samples. I would expect to see a comparison between the proposed method and those kinds of methods [1, 2].\n\nIn fact, what is the benefit of this approach in detecting influential samples compared to those kind of methods if proposed method doesn't bring any improvement?\n\nWang, Sheng-Yu, et al. \"Evaluating Data Attribution for Text-to-Image Models.\" arXiv preprint arXiv:2306.09345 (2023).\nYang, Jiaxi, et al. \"Matching-based Data Valuation for Generative Model.\" arXiv preprint arXiv:2304.10701 (2023).", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "+ the idea if DataInf for approximating influence function is interesting.\n+ method is more efficient that existing work\n+ high-level of correlation between exact influence and approximated one shows the effectiveness of their approach.", "weaknesses": "+ Evaluation setup for mislabeled data detection is not well-defined. I need more details to understand this experiment.\n+ One of the main applications of influence functions is to find the most influential samples whose removal would significantly change model's behavior in inference time. The way this paper evaluates the most influential samples is not appropriate. In fact, we do expect influential samples to come from the same label but that is not enough. I would want to see if the most influential samples are actually influential in the generation process, e.g., model cannot generate that test image/text if those samples are removed in the fine-tuning process.\nA comparison of the effect of removing top $k$ detected influential samples with different methods on the quality of generation for a given test sample is needed.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (poster)