Title: Data Debugging is NP-hard for Classifiers Trained with SGD
Venue: NeurIPS 2024
Accepted: no
Keywords: data debugging

machine learning interpretations

computational complexity
Abstract: Data debugging is to find a subset of the training data such that the model obtained by retraining on the subset has a better accuracy.
A bunch of heuristic approaches are proposed, however, none of them are guaranteed to solve this problem effectively.
This leaves an open issue whether there exists an efficient algorithm to find the subset such that the model obtained by retraining on it has a better accuracy.
To answer this open question and provide theoretical basis for further study on developing better algorithms for data debugging, we investigate the computational complexity of the problem named \textsc{Debuggable}.
Given a machine learning model $\mathcal{M}$ obtained by training on dataset $D$ and a test instance $(\mathbf{x}_\text{test},y_\text{test})$ where $\mathcal{M}(\mathbf{x}_\text{test})\neq y_\text{test}$, \textsc{Debuggable} is to determine whether there exists a subset $D^\prime$ of $D$ such that the model $\mathcal{M}^\prime$ obtained by retraining on $D^\prime$ satisfies $\mathcal{M}^\prime(\mathbf{x}_\text{test})=y_\text{test}$.
To cover a wide range of commonly used models, we take SGD-trained linear classifier as the model and derive the following main results.
(1) If the loss function and the dimension of the model are not fixed, \textsc{Debuggable} is NP-complete regardless of the training order in which all the training samples are processed during SGD.
(2) For hinge-like loss functions, a comprehensive analysis on the computational complexity of \textsc{Debuggable} is provided;
(3) If the loss function is a linear function, \textsc{Debuggable} can be solved in linear time, that is, data debugging can be solved easily in this case.
These results not only highlight the limitations of current approaches but also offer new insights into data debugging.

Abstract

Data debugging is to find a subset of the training data such that the model obtained by retraining on the subset has a better accuracy. A bunch of heuristic approaches are proposed, however, none of them are guaranteed to solve this problem effectively. This leaves an open issue whether there exists an efficient algorithm to find the subset such that the model obtained by retraining on it has a better accuracy. To answer this open question and provide theoretical basis for further study on developing better algorithms for data debugging, we investigate the computational complexity of the problem named DEBUGGABLE. Given a machine learning model M obtained by training on dataset D and a test instance ( x test , y test ) where M ( x test ) = y test, DEBUGGABLE is to determine whether there exists a subset D ′ of D such that the model M ′ obtained by retraining on D ′ satisfies M ′ ( x test ) = y test . To cover a wide range of commonly used models, we take SGD-trained linear classifier as the model and derive the following main results. (1) If the loss function and the dimension of the model are not fixed, DEBUGGABLE is NP-complete regardless of the training order in which all the training samples are processed during SGD. (2) For hinge-like loss functions, a comprehensive analysis on the computational complexity of DEBUGGABLE is provided; (3) If the loss function is a linear function, DEBUGGABLE can be solved in linear time, that is, data debugging can be solved easily in this case. These results not only highlight the limitations of current approaches but also offer new insights into data debugging.

̸

1 Introduction

Given a machine learning model, data debugging is to find a subset of the training data such that 22 the model will have a better accuracy if retrained on that subset [1]. Data debugging serves as a 23 popular method of both data cleaning and machine learning interpretation. In the context of data 24 cleaning, data debugging ( a.k.a. training data debugging [2] or data cleansing [1]) can be used 25 to improve the quality of the training data by removing the flaws leading to mispredictions [3-5]. 26 When it comes to ML interpretation, data debugging locates the part of the training data responsible 27 for unexpected predictions of an ML model. Therefore it is also studied as a training data-based 28 ( a.k.a. instance-based [6]) interpretation, which is crucial for helping system developers and ML 29 practitioners to debug ML system by reporting the harmful part of training data [7]. 30

To solve the data debugging problem, existing researches adopt a two-phase score-based heuristic 31

approach [2]. In the first phase, a score representing the estimated impact on the model accuracy is 32

assigned to each training sample in the training data. It is hoped that the harmful part of training 33

data gets a lower score than the other part. In the second phase, training samples with lower scores 34

are removed greedily and the model is retrained on the modified training data. The two phases are 35

carried out iteratively until a well-trained model is obtained. Most of the related works focus on 36

developing algorithms to estimate the scores efficiently in the first phase [8-16], but rarely study the 37 effectiveness of the entire two-phase approach. 38

39

40

41

42

43

44

45

46

47

48

49

50

Since it is computationally intractable to estimate the score for all possible subsets of the training data, it is often assumed that the score representing the impact of a subset is approximately equal to the sum of the scores of each individual training samples from the subset. However, Koh et. al. [10] showed this is not always the case. For a bunch of subsets sampled from the training data, they empirically studied the difference between the estimated impact and the actual impact of each subset by taking influence functions as the scoring method. The estimated impact is calculated by summing up the score by influence function of each training samples in the subset, and the actual impact is measured by the improvement of accuracy of the model retrained after removing the subset from training data. They found that the estimated impact tends to underestimate the actual impact. Removing a large number of training samples could result in a large deviation between estimated and actual impacts. Although an upper bound of the deviation under certain assumptions has been derived, it is still unknown whether the deviation can be reduced or eliminated efficiently.

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

The above deviation also poses challenges to the effectiveness of the entire approach. Suppose the influence function is adopted as the scoring method, the accuracy of the model is not guaranteed to improve due to the deviation reported in [10] if a large group of training samples are removed during each iteration. Moreover, there is no theoretical analysis for the effectiveness of the greedy approach in the second phase. Even if only one training sample is removed during each iteration of the two-phase approach, the accuracy of the model is still not guaranteed to be improved. The effectiveness of the entire two-phase approach is therefore not assured. This leaves the following open problem:

Problem 1.1. Is there an efficient algorithm to find the subset of the training data, such that the model obtained by retraining on it has a better accuracy?

The computational complexity results presented in this paper demonstrate that it is unlikely to solve the data debugging problem efficiently in polynomial time. To figure out its hardness, we study the problem DEBUGGABLE which is the decision version of data debugging when the test set consists of only one instance. Formally, DEBUGGABLE is defined as follows:

Problem 1.2 (DEBUGGABLE) . Given a classifier M , its training data T , a test instance ( x , y ) . Is there a T ′ ⊆ T , such that M predicts y on x if retrained on T ′ ?

Basically, we prove that DEBUGGABLE is NP-complete, which means data debugging is unlikely to be solved in polynomial time. This result answers the open question mentioned above directly, this is, the large deviation of estimated impacts [10] cannot be reduced or eliminated efficiently. This is because if the impact of a subset of the training data could be accurately estimated as the sum of the impact of each training sample in the subset, data debugging can be solved in polynomial time, which is impossible unless P=NP.

Although DEBUGGABLE is generally intractable, we still hope to develop efficient algorithms tailored to specific cases. Thus it is necessary to figure out the root cause of the hardness for DEBUGGABLE. Previous research are always conducted based on the belief that the complexity of data debugging is due to the chosen model architecture is complicated. However, we show that at least for models trained by stochastic gradient descent (SGD), the hardness stems from the hyper-parameter configuration selected for the SGD training, which was not yet aware of by previous work. To cover a wide range of commonly used machine learning models, we take linear classifiers as the model and show that even for linear classifiers, DEBUGGABLE is NP-hard as long as they are trained by SGD. Moreover, we provided a comprehensive analysis on hyper-parameter configurations that affect the computational complexity of DEBUGGABLE, including the loss function, the model dimension and the training order. Training order, a.k.a. training data order [17] or order of training samples [18], refers to the order in which each training sample is considered during the SGD. Detailed complexity results are shown in Table 1.

Our contribution can be concluded as follows:

We studied the computational complexity of data debugging and showed that data debugging is NP-hard for linear classifiers in the general setting for all possible training orders .

We studied the complexity of DEBUGGABLE when the loss is fixed as the hinge-like function. For 2 or higher dimension, DEBUGGABLE is NP-complete when the training order

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

is adversarially chosen; For one-dimensional cases, DEBUGGABLE can be NP-hard when the interception β < 0 , and is solvable in linear time when β ≥ 0 .

We proved that DEBUGGABLE is solvable in linear time when the loss function is linear.

Moreover, we have a discussion on the implications of these complexity results for machine learning interpretability and data quality, as well as limitations of score-based greedy methods. Our results suggest the further study as follows. (1) It is better to characterize the training sample and find the criterion which can be used to decide the existence of efficient algorithms; (2) Designing algorithms with CSP-solver is a potential way to solve data debugging more efficiently than the brute-force one; (3) Developing random algorithms is a potential way to solve data debugging successfully with high probability.

1.1 Related Works

The solution of data debugging has applications in database query results reliability enhancement [2, 19], training data cleaning [1] and machine learning interpretation[9, 8, 10, 20, 21]. Existing works on data debugging mainly adopt a two-phase approach, which scores the training samples in the first phase and greedily deletes training samples with lower scores in the second phase. Most of the research focus on the first phase. There are mainly two ways of scoring adopted for data debugging in practice. Leave-one-out (LOO) retraining is a widely studied way, which evaluates the contribution of a training sample through the difference in the model's accuracy trained without that training sample. To avoid the cost of model retraining, Koh and Liang took influence functions as an approximation of LOO [8]. After that, various extensions and improvements of the influence function based method are proposed, such as Fisher kernel [9], influence function for group impacts [10], second-order approximations [11] and scalable influence functions [12]. Another way is Shapley-based scoring, where the impact of a training sample is measured by its average marginal contribution to all subsets of the training data [13]. Since Shapley-base scoring suffers from expensive computational cost [22], recent works focus on techniques that efficiently estimate the Shapley value, including Monte-Carlo sampling [13], group testing [14, 15] and using proxy models such as k -NN [16, 3]. However, those methods do not admit any theoretical guarantee on the effectiveness. This paper discusses the limitations of the above methods and suggests some future directions on data debugging.

2 Preliminaries and Problem Definition

Linear classifiers. Formally, a (binary) linear classifier is a function λ w : R d →{-1 , 1 } , where d is called its dimension and w ∈ R d its parameter. Without loss of generality, the bias term of a linear classifier is set as zero in this paper. All vectors in this paper are assumed to be column vectors. For an input x , the value of λ w is defined as

We denote the class of linear models as Λ .

Training data. A training sample is a pair ( x , y ) in which x ∈ R d is the input and y ∈ {-1 , 1 } is the label of x . The training data is a multiset of training samples. We employ w T - → w ′ to denote that the parameter w ′ is obtained by training the parameter w on the training data T , and employ w ( x ,y ) - - - → w ′ to denote that w ′ is obtained by training w on the training sample ( x , y ) .

Loss functions and learning rates. Binary linear classifiers typically use unary functions on y w ⊤ x 129 as their loss functions [23]. Therefore we only consider loss functions of the form L : y w ⊤ x ↦→ R 130 for the rest of the paper. 131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

The linear loss is in the form of

In other words, we have

The hinge-like loss function is defined as the following form

We call β as the interception of L hinge . We represent the learning rate of a model using a vector η = ( η 1 , . . . , η d ) , where η i ≥ 0 and each parameter w i can be updated with the corresponding learning rate η i .

Stochastic gradient descent. The stochastic gradient descent (SGD) method updates parameter w from its initial value w (0) through several epochs. During each epoch, the SGD goes through the entire set of training samples in some training order through several iterations. The training order is defined as a sequence of training samples, in the form of ( x 1 , y 1 ) . . . ( x n , y n ) . For 1 ≤ i < j ≤ n , ( x i , y i ) is considered before ( x j , y j ) during the SGD. We use w i to denote the i -th coordinate of w . We also use w ( e,k ) to denote the value of w at the end of k -th iteration of epoch e and use w ( e ) to denote the value of w after the end of epoch e . Assuming ( x , y ) to be the training sample considered at iteration k , the stochastic gradient descent (SGD) method updates parameter w i for each i by

̸

where η ⊗ ∇L = ( η 1 ∂ L ∂w 1 , . . . , η d ∂ L ∂w d ) is the Hadamard product. We say a training sample x is activated at iteration k during epoch e if ∇L ( y ( w ( e,k -1) ) ⊤ x ) = 0 . The SGD terminates at the end of epoch e if ∥ w ( e -1) -w ( e ) ∥ < ε for threshold ε or e reached some predetermined value. We denote w ∗ = w ( e ) . A linear classifier trained by SGD with the meta-parameters mentioned above is denoted as SGD Λ ( L , η , ε, T ) = λ w ∗ . With a slight abuse of notation, we define SGD Λ ( L , η , ε, T, x ) = λ w ∗ ( x ) . We also use SGD Λ ( T, x ) to avoid cluttering when the context is clear.

Problem definition. With the above definitions, DEBUGGABLE for SGD-trained linear classifiers can be formalized as follows:

We say SGD Λ ( L , η , ε, T ) is debuggable on ( x test , y test ) if ( L , w (0) , η , ε, T, x test , y test ) is a yes-instance of DEBUGGABLE-LIN, and not debuggable on ( x test , y test ) otherwise.

3 Results for Unfixed Loss Functions

In this section, we prove the NP-hardness of DEBUGGABLE-LIN. Intuitively, DEBUGGABLE-LIN is to determine whether there exists a subset T ′ ⊆ T where activated training samples within T ′ drive the parameter w toward the region defined by y test w ⊤ x test > 0 . The activation of training samples depends on the complex interaction between the training data and the model.

Theorem 3.1. DEBUGGABLE-LIN is NP-hard for all training orders.

We only show the proof sketch and leave the details in the appendix.

Proof Sketch. We build a reduction from an NP-hard problem MONOTONE 1-IN-3 SAT [24]: 164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

MONOTONE 1-IN-3 SAT

Input: A 3-CNF formula φ with no negation signs.

Output: 'Yes': if φ has a 1-in-3 assignment, under which each clause contains exactly one true literal;

'No': otherwise.

For example, φ 1 = ( x 1 ∨ x 2 ∨ x 3 ) ∧ ( x 2 ∨ x 3 ∨ x 4 ) is a yes-instance because ( x 1 , x 2 , x 3 , x 4 ) = ( T,F,F,T ) is an 1-in-3 assignment; φ 2 = ( x 1 ∨ x 2 ∨ x 3 ) ∧ ( x 2 ∨ x 3 ∨ x 4 ) ∧ ( x 1 ∨ x 2 ∨ x 4 ) ∧ ( x 1 ∨ x 3 ∨ x 4 ) is a no-instance.

Given a 3-CNF formula φ , our goal is to construct a configuration of the training process, such that the resulting model outputs the correct answer if and only if its training data T ′ encodes an 1-in-3 assignment ν of φ . This can be done by carefully designing the encoding so that for each x i ∈ φ , ν ( x i ) = TRUE if and only if t x i ∈ T ′ . Finally, we can construct some T with T ⊇ T ′ ∪{ t x i | x i ∈ φ } , such that some classifier trained on T is a yes-instance of DEBUGGABLE-LIN if and only if φ is a yes-instance of MONOTONE 1-IN-3 SAT, thereby finishing our proof.

The reduction. Suppose φ has m clauses and n variables, let N = n +2 m +1 . We set the dimension of the linear classifier to N .

The input. Each coordinate of the input is named as

We also use x i to denote the i -th coordinate of x .

The parameters. Each coordinate of the parameter is named as

We also use w i to denote the i -th coordinate of w . Each w x j represents the truth value of variable x j , where 1 represents TRUE and -1 represents FALSE. Similarly, each w c j represents the truth value of clause c j based on the value of its variables. w b j and w dummy are used for convenience of proof.

The initial value of the parameter is set to 183

Loss function. We denote U ( x 0 , δ ) := { x | x 0 -δ < x < x 0 + δ } as the δ -neighborhood of x 0 and 184 define U ( ± x 0 , δ ) = U ( x 0 , δ ) ∪ U ( -x 0 , δ ) . We define the local ramp function as 185

The loss function is defined as 186

L is monotonically decreasing with derivatives 187

189

190

191

192

Learning rate. The learning rate for SGD is set to be 188

Training data. We define two gadgets, var( i ) and clause( i, i 1 , i 2 , i 3 ) , as illustrated in Table 2 and 3. All the unspecified coordinates are set to zero. We use T 0 to denote the training data. var( i ) is contained in T 0 if and only if x i ∈ φ , and clause( i, i 1 , i 2 , i 3 ) is contained in T 0 if and only if c i = ( x i 1 ∨ x i 2 ∨ x i 3 ) ∈ φ .

Threshold and instance. The threshold ε can be any fixed value in R + . The instance is defined as 193 ( x test , y test ) , where y test = 1 and 194

The following reduction works for all possible training orders. Intuitively, during the training process, each var( i ) in the training data will set w x i to around 1 (that is, mark x i as TRUE) in the first epoch, and each clause( i, i 1 , i 2 , i 3 ) will set w c i to near 11 2 in the second epoch, if and only if exactly one of w x i 1 , w x i 2 , w x i 3 is near 1 and the others near -1 (that is, mark c i as satisfied if exactly one of its literals is TRUE and the others FALSE). The training process terminates at the end of the second epoch.

4 Results for Fixed Loss Functions

We have proved the NP-hardness for DEBUGGABLE-LIN when the loss function is not fixed. In this section, we study the complexity when the loss function is fixed as linear and hinge-like functions. Assuming that SGD terminates after only one epoch with a fixed order, we will show that DEBUGGABLE-LIN is solvable in linear time for linear loss. For hinge-like loss functions, DEBUGGABLE-LIN can be solved in linear time only when the dimension d = 1 and the interception β ≥ 0 . For the rest cases, DEBUGGABLE-LIN becomes NP-hard.

4.1 The Easy Case

We start with the linear loss function L = -α ( y w ⊤ x + β ) , with which all the training data are activated and w ∗ = w ∗ ( T ) = w (0) + ∑ ( x ,y ) ∈ T αy η ⊗ x . Since y test ∈ {-1 , 1 } , DEBUGGABLE-LIN is equivalent to deciding whether

A training sample ( x , y ) is 'good' if y test ( αy η ⊗ x ) ⊤ x test > 0 and 'bad' otherwise. The good training-sample assessment (GTA) algorithm, as shown in Algorithm 1, deals with this situation by greedily picking all 'good' training samples.

Denoting T ∗ as the set of all good data in T , it follows that

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

for all T ′ ⊆ T . Hence max T ′ ⊆ T { y test ( w ∗ ( T ′ )) ⊤ x test } = y test ( w ∗ ( T ∗ )) ⊤ x test and DEBUGGABLE216 LIN can be solved by GTA in linear time. The following theorem is straightforward. 217

Theorem 4.1. DEBUGGABLE-LIN is linear time solvable for linear loss functions. 218

Input: Training data T , loss function L , initial parameter w (0) , learning rate η , threshold ε and test instance ( x test , y test ) .

Output: TRUE, iff SGD Λ ( L , η , ε, T ) is debuggable on ( x test y test ) .

220

GTA is still effective for one-dimensional classifiers trained with hinge-like losses when β ≥ 0 .

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

Theorem 4.2. DEBUGGABLE-LIN is linear time solvable for hinge-like loss functions, when d = 1 and β ≥ 0 .

Proof. It suffices to prove that if ∃ T ′ ⊆ T such that SGD Λ ( T ′ , x test ) = y test , SGD Λ ( T ∗ , x test ) = y test . a) Suppose all the data in T ∗ are activated, we have

b) Suppose ( x, y ) ∈ T ∗ is the first inactivated data during the training phase, and w is the current parameter, we have ywx > β . Since αη · ( xy ) · ( x test y test ) ≥ 0 , we have ( x test y test ) · w ≥ 0 . Let T ′′ be the set of training data appeared before ( x, y ) , we have y test w ∗ ( T ∗ ) x test ≥ y test w ∗ ( T ′′ ) x test ≥ 0 .

4.2 The Hard Case

The gradient of training data may not always be activated and could be affected by the training order. When the training order is adversarially chosen, the following theorem shows that DEBUGGABLE-LIN is NP-hard for all d ≥ 2 and β ∈ R .

Theorem 4.3. If the training order is adversarially chosen and d ≥ 2 , DEBUGGABLE-LIN is NP-hard for each hinge-like loss function at every constant learning rate.

Proof sketch. Since the result can be easily extended for all d > 2 by padding the other d -2 dimensions with zeros, we only prove for the case of d = 2 . We assume β ≥ -1 and leave the β < -1 case to the appendix. To avoid cluttering, we further assume η = 1 and α = 1 . The proof can be easily generalized by appropriately re-scaling the constructed vectors.

We build a reduction from the subset sum problem, which is well-known to be NP-hard:

Suppose n = | S | , m = max a ∈ S { a } , γ = max { β, 1 } and S = { a 1 , a 2 , . . . , a n } . We further assume 240 n > 1 . Let the training data be 241

242

243

244

where x i y i = ( √ γ n +1 , 3 √ γa i ) for all 1 ≤ i ≤ n, x c y c = ((18 n 2 m 2 -2) √ γ, -3 t √ γ ) , x b y b = ( √ γ, - √ γ ) , x a y a = ( √ γ, √ γ ) . Let w (0) = ( -18 n 2 m 2 √ γ, 0) . Let the test instance ( x test , y test ) satisfy x test y test = (1 , 0) .

Let the training order be ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x n , y n ) , ( x c , y c ) , ( x b , y b ) , ( x a , y a ) . 245

For each 1 ≤ i < n , suppose w (0) T ∩{ ( x i ,y i ) | 1 ≤ j ≤ i } - - - - - - - - - - - -→ w i , we have 246

This means all the T \ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } can be activated. Thus the resulting parameter 247 trained by T \ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } is 248

It now suffices to prove that for all S ′ ⊆ S , ∑ a ∈ S ′ a = t if and only if ∃ T ′ ⊆ T such that 249 w : w (0) T ′ - → w satisfies y test w ⊤ x test > 0 . 250

If: Suppose ∃ S ′ ⊆ S such that ∑ a ∈ S a = t , we prove that ∃ T ′ ⊆ T such that y test ( w ∗ ) ⊤ x test > 0 251 for w ∗ satisfying w (0) T ′ - → w ∗ . 252

253

Let

T

∗

=

{

(

x

, y

)

|

a

∈

S

′

}

,

T

′

=

T

∗

∪ {

(

x

, y

)

,

(

x

, y

)

,

(

x

, y

)

}

. We have

i

i

i

c

c

b

b

a

a

And therefore y c w ⊤ c x c = γ ( ( -18 n 2 m 2 + | T ∗ | n +1 )(18 n 2 m 2 -2) -9 t 2 ) < -1 ≤ β , so 254

Note that y b w ⊤ b x b = γ ( | T ∗ | n +1 -2) < -1 ≤ β , we have

Note also that y a w ⊤ a x a = γ ( | T ∗ | n +1 -2) < -1 ≤ β , we have

Therefore, y test ( w ∗ ) ⊤ x test = | T ∗ | √ γ n +1 > 0 .

Only if: For each T ′ ⊆ T , let T ∗ = T ′ \ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } . If y test ( w ∗ ) ⊤ x test > 0 for w ∗ satisfying w (0) T ′ - → w ∗ , we prove that ∃ S ′ ⊆ S such that ∑ a ∈ S ′ a = t . We first show that for each T ′ ⊆ T , if w ( w (0) T ′ - → w ) satisfying y test w ⊤ x test > 0 , we have ∀ k ∈ { a, b, c } , ( x k , y k ) ∈ T ′ , y k w ⊤ k x k < γ , where w (0) T ∗ - - → w c ( x c ,y c ) - - - - → w b ( x b ,y b ) - - - - → w a . Otherwise, suppose ∃ k ∈ { a, b, c } such that ( x k , y k ) ̸∈ T ′ or y k w ⊤ k x k ≥ γ , we have

255

256

257

258

259

260

261

262

which contradicts to the fact that y test w ⊤ x test ≥ 0 . 263 Let S ′ = { a i | ( x i , y i ) ∈ T ∗ } and t ′ = ∑ a ∈ S ′ a i , it suffices to prove t ′ = t . Notice that 264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

Hence y c w ⊤ c x c = γ ( -18 n 2 m 2 + | T ∗ | n +1 )(18 n 2 m 2 -2) -9 γtt ′ < -1 ≤ β , thus

Therefore t ′ = t , and this completes the proof.

Moreover, DEBUGGABLE-LIN is NP-hard even when d = 1 and β < 0 .

Theorem 4.4. If the training order is adversarially chosen and d = 1 , DEBUGGABLE-LIN remains NP-hard for each hinge-like loss function with β < 0 at every constant learning rate.

Remarks. The training order in this section can be arbitrary as long as the last three training samples are ( x c , y c ) , ( x b , y b ) , ( x a , y a ) , respectively. All the training samples are 'good' since for each ( x , y ) ∈ T we have x ⊤ x test yy test > 0 . This implies that DEBUGGABLE-LIN is NP-hard even if all the training data are 'good' training samples, and exemplifies why the GTA algorithm fails for higher dimensions.

5 Discussion and Conclusion

In this paper, we provided a comprehensive analysis on the complexity of DEBUGGABLE. We focus on the linear classifier that is trained using SGD, as it is a key component in the majority of popular models.

Since DEBUGGABLE is a special case of data debugging, the above results proved the intractability of data debugging and therefore gives a negative answer to Problem 1.1 declared in the introduction. The complexity results also demonstrated that it is not accurate to estimate the impact of subset of training data by summing up the score of each training samples in the subset, as long as the scores can be calculated in polynomial time .

In Section 4, a training sample is said to be 'good' if it can help the resulting model to predict correctly on the test instance. That is, it can increase y test ( w ∗ ) ⊤ x test . However, in our proof we showed that DEBUGGABLE remains NP-hard even if all training samples are 'good'. This suggests that the quality of a training sample does not depend only on some properties of itself but also on the interaction between the rest of the training data, which should be taken into consideration when developing data cleaning approaches.

Moreover, the NP-hardness of DEBUGGABLE implies that, it is in general intractable to figure out the causality between even the prediction of a linear classifier and its training data. This may be seem surprising since linear classifiers have long been considered 'inherently interpretable'. As warned in [25], a method being 'inherently interpretable' needs to be verified before it can be trusted , the concept of interpretability must be rigorously defined , or at least its boundaries specified.

Our results suggests the following directions for future research. Firstly, characterizing the training sample may be helpful in designing efficient algorithms for data debugging; Secondly, designing algorithms using CSP-solver is a potential way to solve data debugging more efficiently than the bruteforce algorithms; Finally, developing random algorithms is a potential way to solve data debugging successfully with high probability.

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

References

Satoshi Hara, Atsushi Nitanda, and Takanori Maehara. Data Cleansing for Models Trained with SGD . Curran Associates Inc., Red Hook, NY, USA, 2019.

Weiyuan Wu, Lampros Flokas, Eugene Wu, and Jiannan Wang. Complaint-driven training data debugging for query 2.0. pages 1317-1334, 06 2020. doi: 10.1145/3318464.3389696.

Bojan Karlaš, David Dao, Matteo Interlandi, Bo Li, Sebastian Schelter, Wentao Wu, and Ce Zhang. Data debugging with shapley importance over end-to-end machine learning pipelines, 2022.

Felix Neutatz, Binger Chen, Ziawasch Abedjan, and Eugene Wu. From cleaning before ml to cleaning for ml. IEEE Data Eng. Bull. , 44:24-41, 2021. URL https://api.semanticscholar.org/CorpusID: 237542697 .

Peng Li, Xi Rao, Jennifer Blase, Yue Zhang, Xu Chu, and Ce Zhang. Cleanml: A study for evaluating the impact of data cleaning on ml classification tasks. In 2021 IEEE 37th International Conference on Data Engineering (ICDE) , pages 13-24, 2021. doi: 10.1109/ICDE51399.2021.00009.

Juhan Bae, Nathan Ng, Alston Lo, Marzyeh Ghassemi, and Roger Grosse. If influence functions are the answer, then what is the question? In Proceedings of the 36th International Conference on Neural Information Processing Systems , NIPS '22, Red Hook, NY, USA, 2024. Curran Associates Inc. ISBN 9781713871088.

Romila Pradhan, Jiongli Zhu, Boris Glavic, and Babak Salimi. Interpretable data-based explanations for fairness debugging. In Proceedings of the 2022 International Conference on Management of Data , SIGMOD '22, page 247-261, New York, NY, USA, 2022. Association for Computing Machinery. ISBN 9781450392495. doi: 10.1145/3514221.3517886. URL https://doi.org/10.1145/3514221. 3517886 .

Pang Wei Koh and Percy Liang. Understanding black-box predictions via influence functions. In Proceedings of the 34th International Conference on Machine Learning - Volume 70 , ICML'17, page 1885-1894. JMLR.org, 2017.

Rajiv Khanna, Been Kim, Joydeep Ghosh, and Oluwasanmi Koyejo. Interpreting black box predictions using fisher kernels. In International Conference on Artificial Intelligence and Statistics , 2018. URL https://api.semanticscholar.org/CorpusID:53085397 .

Pang Wei Koh, Kai-Siang Ang, Hubert Hua Kian Teo, and Percy Liang. On the accuracy of influence functions for measuring group effects. In Neural Information Processing Systems , 2019. URL https: //api.semanticscholar.org/CorpusID:173188850 .

Samyadeep Basu, Xuchen You, and Soheil Feizi. On second-order group influence functions for blackbox predictions. In Proceedings of the 37th International Conference on Machine Learning , ICML'20. JMLR.org, 2020.

Han Guo, Nazneen Rajani, Peter Hase, Mohit Bansal, and Caiming Xiong. FastIF: Scalable influence functions for efficient model interpretation and debugging. In Marie-Francine Moens, Xuanjing Huang, Lucia Specia, and Scott Wen-tau Yih, editors, Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing , pages 10333-10350, Online and Punta Cana, Dominican Republic, November 2021. Association for Computational Linguistics. doi: 10.18653/v1/2021.emnlp-main.808. URL https://aclanthology.org/2021.emnlp-main.808 .

Amirata Ghorbani and James Y. Zou. Data shapley: Equitable valuation of data for machine learning. ArXiv , abs/1904.02868, 2019. URL https://api.semanticscholar.org/CorpusID:102350503 .

R. Jia, David Dao, Boxin Wang, Frances Ann Hubis, Nicholas Hynes, Nezihe Merve Gürel, Bo Li, Ce Zhang, Dawn Xiaodong Song, and Costas J. Spanos. Towards efficient data valuation based on the shapley value. ArXiv , abs/1902.10275, 2019. URL https://api.semanticscholar.org/CorpusID: 67855573 .

Ruoxi Jia, Fan Wu, Xuehui Sun, Jiacen Xu, David Dao, Bhavya Kailkhura, Ce Zhang, Bo Li, and Dawn Song. Scalability vs. utility: Do we have to sacrifice one for the other in data importance quantification? In 2021 IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR) , pages 8235-8243, 2021. doi: 10.1109/CVPR46437.2021.00814.

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. Proc. VLDB Endow. , 12(11):1610-1623, jul 2019. ISSN 2150-8097. doi: 10.14778/3342263.3342637. URL https://doi.org/10.14778/3342263.3342637 .

Jeremy Mange. Effect of training data order for machine learning. In 2019 International Conference 356 on Computational Science and Computational Intelligence (CSCI) , pages 406-407, 2019. doi: 10.1109/ 357 CSCI49370.2019.00078. 358

359

360

361

Ernie Chang, Hui-Syuan Yeh, and Vera Demberg. Does the order of training samples matter? improving neural data-to-text generation with curriculum learning. ArXiv , abs/2102.03554, 2021. URL https: //api.semanticscholar.org/CorpusID:231846815 .

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

Yejia Liu, Weiyuan Wu, Lampros Flokas, Jiannan Wang, and Eugene Wu. Enabling sql-based training data debugging for federated learning. Proceedings of the VLDB Endowment , 15:388-400, 02 2022. doi: 10.14778/3494124.3494125.

Marc-Etienne Brunet, Colleen Alkalay-Houlihan, Ashton Anderson, and Richard Zemel. Understanding the origins of bias in word embeddings, 2019.

Hao Wang, Berk Ustun, and Flavio P. Calmon. Repairing without retraining: Avoiding disparate impact with counterfactual distributions, 2019.

Xiaotie Deng and Christos H. Papadimitriou. On the complexity of cooperative solution concepts. Math. Oper. Res. , 19:257-266, 1994. URL https://api.semanticscholar.org/CorpusID:12946448 .

Qi Wang, Yue Ma, Kun Zhao, and Yingjie Tian. A comprehensive survey of loss functions in machine learning. Annals of Data Science , 9, 04 2022. doi: 10.1007/s40745-020-00253-5.

Erik D. Demaine, William Gasarch, and Mohammad Hajiaghayi. Computational Intractability: A Guide to Algorithmic Lower Bounds . MIT Press, 2024.

Alon Jacovi and Yoav Goldberg. Towards faithfully interpretable nlp systems: How should we define and evaluate faithfulness? In Annual Meeting of the Association for Computational Linguistics , 2020. URL https://api.semanticscholar.org/CorpusID:215416110 .

Victor Parque. Tackling the subset sum problem with fixed size using an integer representation scheme. In 2021 IEEE Congress on Evolutionary Computation (CEC) , pages 1447-1453, 2021. doi: 10.1109/ CEC45853.2021.9504889.

381

382

383

384

385

386

387

388

A Detailed Proofs for Section 3

Notations. Given some orderings { o e } of training data, where o e t as the order of t in epoch e . We use w ( e,l ) x i to denote the value of w x i after the l -th iteration in epoch e . We also denote x t and y t as the feature and the label of training data t , respectively. We denote t ( e,l ) as the training sample being considered during epoch e , iteration l .

Lemma A.1. Suppose T ⊆ T 0 is the training data and let T e l,r = { t ( e,l ) , t ( e,l +1) , . . . , t ( e,r ) } be the set of consecutive training samples considered during epoch e from iteration l to r . For 1 ≤ l ≤ r ≤ | T | , if clause ( γ, i 1 , i 2 , i 3 ) ̸∈ T e l,r , then w ( e,l -1) c γ = w ( e,r ) c γ .

Proof. For each t ∈ T e l,r , we have ( x t ) c γ = 0 . Therefore 389

Hence ∂ L ∂c γ ∣ ∣ ∣ t = 0 , and 390

and 400

Lemma A.2. Suppose T ⊆ T 0 is the training data and T l := { t (1 , 1) , . . . , t (1 ,l ) } . ∀ 1 ≤ i ≤ n, 1 ≤ l ≤ | T | , w (1 ,l ) x i ∈ U (1 , l +1 6000 N 2 ) if var( i ) ∈ T l ; Otherwise w (1 ,l ) x i ∈ U ( -1 , l +1 6000 N 2 ) .

Proof. We prove this lemma by induction.

Similarly, ( x t ) b γ = 0 , and 391

392

393

394

395

396

397

398

Basic Case: Note that for all 1 ≤ i ≤ n , w (0) x i = -1 , and for all 1 ≤ γ ≤ m,w (0) c γ = 1 / 2 , w (0) b γ = -1 . We denote t = t (1 , 1) to avoid cluttering. For any fixed i :

(1) If t = var( i ) . We have y t ( w (0) ) ⊤ x ′ t = 5 w (0) x i = -5 , hence 399

(2) If t = clause( γ, i, i ′ , i ′′ ) . We have 401

Hence ∂ L ∂b γ ∣ ∣ ∣ t = 0 , and hence 402

and 403

and thus 414

We have ∂ L ∂w x i ∣ ∣ ∣ t = -1 1000 N and w (1 ,l +1) x i = w (1 ,l ) x i -η x i ∂ L ∂w x i ∣ ∣ ∣ t = w (1 ,l ) x i + 1 6000 N 2 . Consider the 415 following cases: 416

417

418

If var ( i ) ∈ T l , then var ( i ) ∈ T l +1 and w (1 ,l ) x i ∈ U (1 , l +1 6000 N 2 ) . Therefore w (1 ,l +1) x i ∈ U (1 , l +2 6000 N 2 ) .

419

420

421

422

423

424

425

426

If var ( i ) ̸∈ T l , then var ( i ) ̸∈ T l +1 and w (1 ,l ) x i ∈ U ( -1 , l +1 6000 N 2 ) . Therefore w (1 ,l +1) x i ∈ U ( -1 , l +2 6000 N 2 ) .

(3) Otherwise, w x i will not be updated, and w (1 ,l +1) x i = w (1 ,l ) x i . If var ( i ) ∈ T l then var ( i ) ∈ T l +1 and w (1 ,l +1) x i ∈ U (1 , l +2 6000 N 2 ) ; Otherwise var ( i ) ̸∈ T l +1 and w (1 ,l +1) x i ∈ U ( -1 , l +2 6000 N 2 ) .

Hence if the lemma is true for l < | T | , it is also true for l +1 . Therefore, the lemma is true for all 1 ≤ l ≤ | T | .

Corollary A.1. Suppose T ⊆ T 0 is the training data. ∀ 1 ≤ i ≤ n, 1 ≤ l ≤ | T | , if var( i ) ∈ T , then w (1) x i ∈ U (1 , 1 6000 N ) . Otherwise w (1) x i ∈ U ( -1 , 1 6000 N ) .

(3) Otherwise, w x i will not be updated. Therefore w (1 , 1) x i = w (0) x i = -1 ∈ U ( -1 , 2 6000 N 2 ) . 404

Hence this lemma is true for l = 1 . 405

Induction Step: Suppose the lemma is true for l < | T | . We prove that this lemma remains true for 406 l +1 . We denote t = t (1 ,l +1) to avoid cluttering. This makes sense since l +1 ≤ | T | and thus t ∈ T . 407 For any fixed i : 408

If t = var( i ) , then var( i ) ̸∈ T l because there are at most one var( i ) in T for each i . 409

410

411

Therefore w (1 ,l ) x i ∈ U ( -1 , l +1 6000 N 2 ) . We have y t ( w (1 ,l ) ) ⊤ x ′ t = 5 w (1 ,l ) x i ∈ U ( -5 , 0 . 01) , and ∂ L ∂w x i ∣ ∣ ∣ t = -12 N 5 y t ( x t ) i = -12 N . Hence

(2) If t = clause( γ, i, i ′ , i ′′ ) . In this case, clause( γ, · , · , · ) ̸∈ T 1 1 ,l and by Lemma A.1 we have 412 w (1 ,l ) c γ = w (0) c γ , w (1 ,l ) b γ = w (0) b γ . From the induction hypothesis we have 413

Proof. Note that w (1) x i = w (1 , | T | ) x i and N = 2 m + n +1 . By Lemma A.2, if var( i ) ∈ T we have 427

428

429

430

431

Lemma A.3. Suppose T ⊆ T 0 is the training data. ∀ 1 ≤ γ ≤ m , if ∃ 1 ≤ i 1 , i 2 , i 3 ≤ n such that clause( γ, i 1 , i 2 , i 3 ) ∈ T , then w (1) b γ = 0 , w (1) c γ = 1 2 + 1 200 N ; Otherwise, w (1) b γ = -1 , w (1) c γ = 1 2 .

Proof. (1) If such t γ = clause( γ, i 1 , i 2 , i 3 ) exists in T , by Lemma A.2 we have 432

By Lemma A.1 we have w (1 ,o 1 t γ -1) c γ = w (0) c γ and w (1 ,o 1 t γ -1) b γ = w (0) b γ because clause( γ, · , · , · ) ̸∈ 433 T 1 1 ,o t γ -1 . Hence 434

We have ∂ L ∂w cγ ∣ ∣ ∣ t γ = -1 1000 N , and 435

Similarly, ∂ L ∂w bγ ∣ ∣ ∣ t γ = -1 2000 N and 436

Note also that clause( γ, · , · , · ) ̸∈ T 1 o t γ , | T | , by Lemma A.1 we have 437

439

440

(2) If such t γ = clause( γ, i 1 , i 2 , i 3 ) does not exist in T , by Lemma A.1 we have w (1) c γ = w (0) c γ = 1 2 and w (1) b γ = w (0) b γ = -1 .

441

442

Lemma A.4. Suppose T ⊆ T 0 and C l be the number of clause () in T 2 1 ,l . ∀ 1 ≤ i ≤ n, 1 ≤ l ≤ | T | , w (2 ,l ) x i ∈ U (1 , C l +1 / 2 6 N ) if var ( i ) ∈ T ; Otherwise w (2 ,l ) x i ∈ U ( -1 , C l +1 / 2 6 N ) .

Proof. Similar to the proof of A.2, we prove this lemma by induction. 443

Basic Case: Note that for all 1 ≤ i ≤ n , w (1) x i = U ( ± 1 , 1 6000 N ) , and for all 1 ≤ γ ≤ m,w (1) c γ ∈ 444 { 1 2 , 1 2 + 1 200 N } , w (1) b γ ∈ {-1 , 0 } . We denote t = t (2 , 1) to avoid cluttering. For any fixed i : 445

(1) If t = var( i ) , C 1 = 0 . By Corollary A.1, w (1) x i = U (1 , 1 6000 N ) . We have 446

If var( i ) ̸∈ T , we have

hence ∂ L ∂w x i ∣ ∣ ∣ t = 0 , and 447

If var ( i ) ̸∈ T , 454

455

456

457

458

459

460

461

462

463

464

we have 465

(2) If t = clause( γ, i, i ′ , i ′′ ) , C 1 = 1 . By Lemma A.3, we have w (1) c γ = 1 2 + 1 200 N and w (1) b γ = 0 . 448 Therefore, 449

hence ∂ L ∂w x i ∣ ∣ ∣ t ∈ { 0 , -yx x i } = {-1 , 0 } , and η x i ∂ L ∂w x i ∣ ∣ ∣ t ∈ {-1 6 N , 0 } . 450

By Corollary A.1, if var ( i ) ∈ T , we have 451

If var ( i ) ̸∈ T , we have 452

(3) Otherwise, w x i will not be updated and C 1 ≤ 1 . Therefore if var ( i ) ∈ T , 453

Hence this lemma is true for l = 1 .

Induction Step: Suppose the lemma is true for l < | T | . We prove that this lemma remains true for l +1 . We denote t = t (2 ,l +1) to avoid cluttering. This makes sense since l +1 ≤ | T | and thus t ∈ T . For any fixed i :

(2) If t = clause( γ, i, i ′ , i ′′ ) , C l +1 = C l +1 . In this case, clause( γ, · , · , · ) ̸∈ T 2 1 ,l and by Lemma A.1 and Lemma A.3 we have w (2 ,l ) c γ = w (1) c γ = 1 2 + 1 200 N , w (2 ,l ) b γ = w (1) b γ = 0 . From the induction hypothesis we have w (2 ,l ) x i , w (2 ,l ) x i ′ , w (2 ,l ) x i ′′ ∈ U ( ± 1 , C l +1 / 2 6 N ) . Noting that

469

470

(3) Otherwise, w x i will not be updated. We have C l +1 ≤ C l +1 w (2 ,l +1) x i = w (2 ,l ) x i . If var ( i ) ∈ T then w (2 ,l +1) x i ∈ U (1 , C l +1 +1 / 2 6 N ) ; If var ( i ) ̸∈ T then w (2 ,l +1) x i ∈ U ( -1 , C l +1 +1 / 2 6 N ) .

471

472

473

474

Hence if the lemma is true for l < | T | , it is also true for l +1 . Therefore, the lemma is true for all 1 ≤ l ≤ | T | .

Corollary A.2. Suppose T ⊆ T 0 is the training data. ∀ 1 ≤ i ≤ n , if var( i ) ∈ T , then w (2) x i ∈ U (1 , 0 . 1) . Otherwise w (2) x i ∈ U ( -1 , 0 . 1) .

Proof. Note that w (2) x i = w (2 , | T | ) x i and C | T | ≤ m . By Lemma A.4, if var( i ) ∈ T we have 475

If var( i ) ̸∈ T , we have 476

477

478

479

480

481

482

Lemma A.5. Suppose T ⊆ T 0 is the training data. ∀ 1 ≤ i ≤ m , if ∃ 1 ≤ i 1 , i 2 , i 3 ≤ n such that clause( i, i 1 , i 2 , i 3 ) ∈ T , then

Otherwise, w (2) b i = -1 , w (2) c i = 1 2 . 483

Proof. (1) If such t γ = clause( γ, i 1 , i 2 , i 3 ) exists in T , by Lemma A.4 we have 484

By Lemma A.1 we have w (2 ,o 1 t γ -1) c γ = w (1) c γ = 1 2 + 1 200 N and w (2 ,o 1 t γ -1) b γ = w (1) b γ = 0 because 485 clause( γ, · , · , · ) ̸∈ T 1 1 ,o t γ -1 . Consider the following two cases: 486

(a) If exactly one of var ( i 1 ), var ( i 2 ), var ( i 3 ) is in T , by Corollary A.2 we have 487

Hence ∂ L ∂w cγ ∣ ∣ ∣ t γ = -1 , and 488

Similarly, 489

Note also that clause( γ, · , · , · ) ̸∈ T 1 o t γ , | T | , by Lemma A.1 we have w (2) c γ = w (2 , | T | ) c γ = w (2 ,o 1 t γ ) c γ = 490 11 2 -1 200 N and w (2) b γ = w (2 , | T | ) b γ = w (2 ,o 1 t γ ) b γ = 1000 N . 491

(b) Otherwise, we have 492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

Hence ∂ L ∂w cγ ∣ ∣ ∣ t γ = ∂ L ∂w bγ ∣ ∣ ∣ t γ = 0 , so w (2 ,o 1 t γ ) c γ = w (2 ,o 1 t γ -1) c γ = 1 2 + 1 200 N , w (2 ,o 1 t γ ) b γ = w (2 ,o 1 t γ -1) b γ = 0 .

Note also that clause( γ, · , · , · ) ̸∈ T 1 o t γ , | T | , by Lemma A.1 we have w (2) c γ = w (2 , | T | ) c γ = w (2 ,o 1 t γ ) c γ = 1 2 + 1 200 N and w (2) b γ = w (2 , | T | ) b γ = w (2 ,o 1 t γ ) b γ = 0 .

(2) If such t γ = clause( γ, i 1 , i 2 , i 3 ) does not exist in T , by Lemma A.1 and Lemma A.3 we have w (2) c γ = w (1) c γ = 1 2 and w (2) b γ = w (1) b γ = -1 .

Moreover, w reaches its fixpoint at the end of the second epoch and will no longer be updated. Lemma A.6. w (2) = w (3) .

̸

̸

Proof. Suppose w (2) = w (3) , then there exists 1 ≤ i ≤ N such that w (2) i = w (3) i , and there are some training sample t in the training data such that ∂ L ∂w (2) i ∣ ∣ ∣ ∣ t = 0 . Let t = ( x t , y t ) and I = U ( -5 , 0 . 01) ∪ U ( -1 2 , 0 . 26) ∪ ( ⋃ x 0 ∈{± 1 , ± 3 } U ( x 0 , 0 . 01) ) . By (2) we have y t ( w (2) ) ⊤ x t ′ ∈ I . At least one of the following is true:

̸

∃ 1 ≤ i ≤ n, t = var( i ) . According to lemma A.2, y t ( w (2) ) ⊤ x t ′ = yw (2) x i x i ∈ U (5 , 0 . 5) ⊆ R \ I , contradicting to y t ( w (2) ) ⊤ x t ′ ∈ I .

∃ 1 ≤ i ≤ m and 1 ≤ i 1 , i 2 , i 3 ≤ n , such that t = clause( i, i 1 , i 2 , i 3 ) . According to lemma A.5, we have

We have y t ( w (2) ) ⊤ x t ′ ̸∈ I , another contradiction.

Therefore w (2) = w (3) , w reaches its fixpoint at the end of the second epoch. In other words, 509 w ∗ = w (2) . 510

We are now ready to give a rigorous proof of theorem 3.1. 511

Proof of theorem 3.1. It only suffices to prove the correctness of the reduction in section 3. 512

513

514

515

516

If. Suppose φ ∈ MONOTONE 1-IN-3 SAT, then there is a truth assignment ν ( · ) that assigns exactly one variable in each clause of φ is true. Let ∆ = { var ( i ) | ν ( x i ) = FALSE } . Let w ′ be the parameter of SGD Λ ( T 0 \ ∆) . By Lemma A.5, ( w ′ ) c γ = 11 2 + 1 200 N for all 1 ≤ γ ≤ m , hence

and λ w ′ ( x test ) = 1 , thus SGD Λ ( T 0 ) is thus debuggable.

Only if. Suppose SGD Λ ( T 0 ) is debuggable, there will be a ∆ such that SGD Λ ( T 0 , x test ) = y test . We 517 denote w ′ as the parameter trained by SGD on T 0 \ ∆ . We have λ w ′ ( x test ) = 1 and ( w ′ ) ⊤ x test ≥ 0 . 518 By Lemma A.5, w ′ c γ = { 1 2 + 1 200 N , 11 2 + 1 200 N } . Suppose w c ∗ = 1 2 + 1 200 N , then 519

̸

leading to a contradiction.

As a consequence, w ′ c γ = 11 2 + 1 200 N for all 1 ≤ γ ≤ m . By Lemma A.5, exactly one of var ( i 1 ), var ( i 2 ), var ( i 3 ) is in T 0 \ ∆ for each c γ = ( x i 1 ∨ x i 2 ∨ x i 3 ) . Consider a truth assignment ν that maps every x i to FALSE where var ( i ) ∈ ∆ , and maps the rest to TRUE. Then ν assigns exactly one variable true in each c γ = ( x i 1 ∨ x i 2 ∨ x i 3 ) if and only if exactly one of var ( i 1 ), var ( i 2 ), var ( i 3 ) is in T 0 \ ∆ . Hence ν is a truth assignment that assigns true to exactly one variable in each clause of φ , and thus φ is a yes-instance of MONOTONE 1-IN-3 SAT.

B Detailed Proofs for Section 4

B.1 Proof of Theorem 4.4

Proof. We build a reduction from the SUBSET SUM problem with a fixed size, which is NP-hard as a particular case of the class of knapsack problems [26]. Formally, it is defined as:

SUBSET SUM with a fixed size

Input:

A set of positive integer S , and two positive integers t, k .

Output:

'Yes': if

∃

S

′

⊆

S

of size

k

such that

∑

a

∈

S

′

a

=

t

;

'No': otherwise.

The ordered training data T is constructed as 532

where x i y i = 2 3 + a i 3 ∑ a ∈ S a for all 1 ≤ i ≤ n and x a y a = 1 + 1 6 ∑ a ∈ S a . Let η = 1 , α = 1 , β = -1 , 533 w (0) = -1 -2 3 k -t 3 ∑ a ∈ S a and let the test instance ( x test , y test ) satisfy x test y test = 1 . It now suffices 534 to prove that ∃ S ′ ⊆ S such that | S ′ | = k and ∑ a ∈ S ′ a = t if and only if ∃ T ′ ⊆ T such that 535 w : w (0) T ′ - → w satisfies y test wx test > 0 . 536

520

521

522

523

524

525

526

527

528

529

530

531

Since

and ∀ 1 ≤ i ≤ n, x i y i > 2 3 , for each 1 ≤ i < n , suppose w (0) T ∗ ∩{ ( x j ,y j ) | 1 ≤ j ≤ i } - - - - - - - - - - - - - → w i , we have

That is, each training sample in T ∗ is activated. Then for w (0) T ∗ - - → w a , we have w a = -1 . Then, 539 since y a w a x a = -(1 + 1 6 ∑ a ∈ S a ) < β and w a ( x a ,y a ) - - - - - → w ∗ we have w ∗ = w a + x a y a = 1 6 ∑ a ∈ S a . 540 Therefore, y test w ∗ x test = 1 6 ∑ a ∈ S a > 0 . 541

Only if: For each T ′ ⊆ T , let T ∗ = T ′ \ { ( x a , y a ) } and c ( T ∗ ) be the set of training samples in 542 T ∗ that are activated. If y test w ∗ x test ≥ 0 for w ∗ satisfying w (0) T ′ - → w ∗ , we prove that the set 543 S ′ = { a i | ( x i , y i ) ∈ c ( T ∗ ) } satisfies | S ′ | = k and ∑ a ∈ S ′ a = t . 544

We first show that y test w a x test < 0 for w (0) c ( T ∗ ) -- - → w a . Otherwise, suppose y test w a x test ≥ 0 we 545 have w a ≥ 0 . Let ( x, y ) be the last training sample of c ( T ′ ) , since 2 3 < xy ≤ 1 , we have 546 w ′ ≥ w a -xy ≥ -1 for w ′ ( x,y ) - - - → w a . Thus yw ′ x ≥ β , which contradicts to the definition of c ( T ∗ ) . 547

We next show that | S ′ | = k . Suppose | S ′ | ≤ k -1 , we have

Thus w ∗ ≤ w a + x a y a < -4 3 +(1 + 1 6 ∑ a ∈ S a ) < 0 and then y test w ∗ x test < 0 , which contradicts to 548 the fact that y test w ∗ x test ≥ 0 . Therefore | S ′ | ≥ k . 549

Suppose | S ′ | ≥ k +1 , we have

Then y a w a x a ≥ ( -2 3 ) · (1 + 1 6 ∑ a ∈ S a ) ≥ -7 9 ≥ β , that is, ( x a , y a ) is not activated and w ∗ = w a . 550 Then since y test w a x test < 0 , we have y test w ∗ x test = y test w a x test < 0 , which contradicts to the fact that 551 y test w ∗ x test ≥ 0 . Therefore | S ′ | = k . 552

It remains to prove that ∑ ′ a = t . Otherwise, suppose ∑ ′ a ≤ t -1 , we have

Thus y test w ∗ x test ≤ y test ( w a + x a y a ) x test ≤ -1 6 ∑ a ∈ S a < 0 , which contradicts to the fact that 553 y test w ∗ x test ≥ 0 . Therefore ∑ a ∈ S ′ a ≥ t . 554

Suppose ∑ a ∈ S ′ a ≥ t +1 we have

555

556

557

558

559

560

561

562

563

564

Thus

That is, ( x a , y a ) is not activated and w ∗ = w a . Then since y test w a x test < 0 , we have y test w ∗ x test = y test w a x test < 0 , which contradicts to the fact that y test w ∗ x test ≥ 0 . Therefore ∑ a ∈ S ′ a = t .

B.2 Proof of Theorem 4.3 for β < -1

Proof. To avoid cluttering, we still assume η = 1 and α = 1 . The proof can be generalized by appropriately re-scaling the constructed vectors.

Let M = -β ( n + 2) + 9 βnm 2 ( n + 1) + 3 . Suppose n = | S | > 1 , m = max a ∈ S { a } and S = { a 1 , a 2 , . . . , a n } . We further assume n > 1 . Let the ordered set of training samples be

where x i y i = ( 1 n +1 , -3 βa i ) for all 1 ≤ i ≤ n, x c y c = ( M + 3 2 β -1 , β (3 t -1 2 )) , x b y b = (1 , -1) , x a y a = ( -3 2 β, -3 2 β ) . Let w (0) = ( -M, 0) . Let the test instance ( x test , y test ) satisfy x test y test = (1 , 0) .

For each 1 ≤ i < n , suppose w (0) T ∩{ ( x i ,y i ) | 1 ≤ j ≤ i } - - - - - - - - - - - -→ w i , we have 565

This means all the ( x i , y i ) ∈ T \ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } can be activated and thus the resulting 566 parameter trained by T \ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } is 567

It now suffices to prove that for all S ′ ⊆ S , ∑ a ∈ S ′ a = t if and only if ∃ T ′ ⊆ T such that 568 w : w (0) T ′ - → w such that y test w ⊤ x test > 0 . 569

If: Suppose ∃ S ′ ⊆ S such that ∑ a ∈ S a = t , we prove that ∃ T ′ ⊆ T such that y test ( w ∗ ) ⊤ x test > 0 570 for w ∗ satisfying w (0) T ∗ - - → w ∗ . 571

Let T ∗ = { ( x i , y i ) | a i ∈ S ′ } , T ′ = T ∗ ∪ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } . We have 572

And y c w ⊤ c x c = ( -M + | T ∗ | n +1 )( M + 3 2 β -1) -3 tβ 2 (3 t -1 2 ) < β , so 573

Note that β < -1 , we have y b w ⊤ b x b = | T ∗ | n +1 +2 β < ( β + | T ∗ | n +1 ) + β < β , and 574

Note also that y a w ⊤ a x a = 3 2 ( -β )( | T ∗ | n +1 -1 + β ) < β , we have 575

Therefore, y test ( w ∗ ) ⊤ x test = | T ∗ | n +1 ≥ 0 . 576

Only if: For each T ′ ⊆ T , let T ∗ = T ′ \ { ( x c , y c ) , ( x b , y b ) , ( x a , y a ) } , if y test ( w ∗ ) ⊤ x test for w ∗ 577 satisfying w (0) T ′ - → w ∗ , we prove that ∃ S ′ ⊆ S such that ∑ a ∈ S ′ a = t . We first show that for 578 each T ′ ⊆ T , if w ( w (0) T ′ - → w ) satisfying y test w ⊤ x test ≥ 0 , we have ∀ k ∈ { a, b, c } , ( x k , y k ) ∈ 579 T ′ , y k w ⊤ k x k < β , where w (0) T ∗ - - → w c ( x c ,y c ) - - - - → w b ( x b ,y b ) - - - - → w a . Otherwise, suppose ∃ k ∈ { a, b, c } 580 such that ( x k , y k ) ̸∈ T ′ or y k w ⊤ k x k ≥ β , we have 581

which contradicts to the fact that y test w ⊤ x test ≥ 0 . 582 Let S ′ = { a i | ( x i , y i ) ∈ T ∗ } and t ′ = ∑ a ∈ S ′ a i , it suffices to prove t ′ = t . Notice that 583

Hence y c w ⊤ c x c = ( -M + | T ∗ | n +1 )( M + 3 2 β -1) -3 t ′ β 2 (3 t -1 2 ) < β , thus 584

(1) If t ′ ≤ t -1 , we have 585

a contradiction. Hence w a = w b ( x b ,y b ) - - - - → w a = ( | T ∗ | n +1 + 3 2 β, -3 β ( t ′ -t ) -1 2 β -1) . 586 (2) If t ′ ≥ t +1 , we have 587

another contradiction. Therefore t ′ = t , and this completes the proof. 588 589

590

C Limitations

It is important to emphasize that the complexity results in section 4 requires the training order to 591 be adversarially chosen. The complexity of DEBUGGABLE for randomly chosen training order is 592 unclear and needs to be figured out in the future research. 593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

625

626

627

628

629

630

631

632

633

634

635

636

637

638

639

640

641

642

643

644

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: The main results are discussed in section 3 and section 4.

Guidelines:

The answer NA means that the abstract and introduction do not include the claims made in the paper.

The abstract and/or introduction should clearly state the claims made, including the contributions made in the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.

The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.

It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: See section C in the appendix.

Guidelines:

The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.

The authors are encouraged to create a separate "Limitations" section in their paper.

The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.

The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with a few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.

The authors should reflect on the factors that influence the performance of the approach. For example, a facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or a speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.

The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.

If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.

While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, a worse outcome might be that reviewers discover limitations that aren't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an important role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: The proof of theorem 3.1 is available in section A; The proof of theorem 4.1 and theorem 4.2 are available in section 4; The proof of theorem 4.3 is available in section 4 and section B; The proof of theorem 4.4 is available in section B.

Guidelines:

The answer NA means that the paper does not include theoretical results.

All the theorems, formulas, and proofs in the paper should be numbered and crossreferenced.

All assumptions should be clearly stated or referenced in the statement of any theorems.

The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition.

Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.

Theorems and Lemmas that the proof relies upon should be properly referenced.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [NA]

Justification: This paper does not include experiments.

Guidelines:

The answer NA means that the paper does not include experiments.

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.

If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.

Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.

While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example

(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.

(b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.

(c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).

(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [NA]

Justification: This paper does not include experiments requiring code.

Guidelines:

The answer NA means that paper does not include experiments requiring code.

Please see the NeurIPS code and data submission guidelines ( https://nips.cc/ public/guides/CodeSubmissionPolicy ) for more details.

While we encourage the release of code and data, we understand that this might not be possible, so 'No' is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for a new open-source benchmark).

The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurIPS code and data submission guidelines ( https: //nips.cc/public/guides/CodeSubmissionPolicy ) for more details.

The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.

The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only a subset of experiments are reproducible, they should state which ones are omitted from the script and why.

At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).

Providing as much information as possible in supplemental material (appended to the paper) is recommended, but including URLs to data and code is permitted.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [NA]

Justification: This paper does not include experiments.

Guidelines:

The answer NA means that the paper does not include experiments.

The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them.

The full details can be provided either with the code, in appendix, or as supplemental material.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [NA]

Justification: This paper does not include experiments.

Guidelines:

The answer NA means that the paper does not include experiments.

The authors should answer "Yes" if the results are accompanied by error bars, confidence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.

The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).

The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)

The assumptions made should be given (e.g., Normally distributed errors).

It should be clear whether the error bar is the standard deviation or the standard error of the mean.

It is OK to report 1-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have a 96% CI, if the hypothesis of Normality of errors is not verified.

For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative error rates).

If error bars are reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables in the text.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [NA]

Justification: This paper does not include experiments.

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: They authors have made sure that the research conducted in the paper conform with the NeurIPS Code of Ethics.

Guidelines:

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.

If the authors answer No, they should explain the special circumstances that require a deviation from the Code of Ethics.

The authors should make sure to preserve anonymity (e.g., if there is a special consideration due to laws or regulations in their jurisdiction).

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [NA]

Justification: The impacts are discussed in section 5

Guidelines:

The answer NA means that there is no societal impact of the work performed.

If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact.

Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.

The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.

The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.

If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [NA]

Justification: This paper only provides theoretical results and poses no such risks.

Guidelines:

The answer NA means that the paper poses no such risks.

Released models that have a high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere to usage guidelines or restrictions to access the model or implementing safety filters.

Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.

We recognize that providing effective safeguards is challenging, and many papers do not require this, but we encourage authors to take this into account and make a best faith effort.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [NA]

Justification: This paper does not use existing assets.

Guidelines:

The answer NA means that the paper does not use existing assets.

The authors should cite the original paper that produced the code package or dataset.

The authors should state which version of the asset is used and, if possible, include a URL.

The name of the license (e.g., CC-BY 4.0) should be included for each asset.

For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should be provided.

If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswithcode.com/datasets has curated licenses for some datasets. Their licensing guide can help determine the license of a dataset.

For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided.

If this information is not available online, the authors are encouraged to reach out to the asset's creators.

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [NA]

Justification: This paper does not release new assets.

Guidelines:

The answer NA means that the paper does not release new assets.

Researchers should communicate the details of the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.

The paper should discuss whether and how consent was obtained from people whose asset is used.

At submission time, remember to anonymize your assets (if applicable). You can either create an anonymized URL or include an anonymized zip file.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: This paper does not involve crowdsourcing nor research with human subjects.

Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper.

According to the NeurIPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: This paper does not involve crowdsourcing nor research with human subjects. Guidelines:

The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.

Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.

We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.

For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper studies the computational complexity of data debugging, defined as finding a subset of the training data such that the model obtained by retraining on this subset has better accuracy. The paper focuses on linear models and investigates various loss functions, showing that in some cases, the debugging problem is NP-complete, while in others, it can be solved in linear time.\n\nSTRENGTHS:\nThe paper analyzes the computational complexity of linear classifiers with both fixed and non-fixed loss functions. First, it shows that in the general case of non-fixed loss functions and dimensions, the problem of debugging is NP-hard. However, for hinge-loss-like functions, depending on the dimension of the features and the sign of the intercept, the problem could be either NP-hard or solvable in linear time.\n\nThis result also implies that it is not accurate to estimate the impact of a subset of training data by summing up the scores of each training sample in the subset if we assign each sample point a scoring number.\n\nWEAKNESSES:\n- The model studied in the paper is limited to linear classifiers, which is very restrictive.\n\n- Most of the manuscript is devoted to proving the theorems rather than discussing and interpreting the implications of the results.\n\n- The setting involves debugging for any possible test point, which is far from practical.\n\nQUESTIONS:\nThe definition of DEBUGGABLE-LIN seems very pessimistic as it tries to find a subset for any possible test point. However, in practice and in learning theory, one is interested in testing a point that comes from the same distribution as the training data or at least a distribution similar to the training data. Considering this practical scenario, would the problem still be NP-hard?\n\nLIMITATIONS:\nThe paper does not have any potential negative societal impact.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 2, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-09"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis work investigates the computational complexity of the data debugging problem, i.e. the problem of identifying a subset of training data that, when removed, improves model accuracy on a given test point. Via standard complexity theoretic reductions, it establishes the NP-hardness of this problem for linear classifiers trained with SGD under various conditions.\n\nSTRENGTHS:\nThe paper is well written with the key problem being well motivated. The proofs are succinct and easy to follow.\n\nWEAKNESSES:\nMy key concern with the paper is that the constructions underlying the hardness results are immensely contrived and far removed from how classifiers are actually trained in practice. This casts severe doubts as to whether the key results of the paper implies anything significant about the hardness of data debugging as is performed in practice. To elucidate a few instances:\n\n1. **Theorem 3.1**: The reduction to Monotone 1-in-3 SAT in Theorem 1 hinges on an adversarially constructed loss function (Line 186), one that is very far removed from any loss function I’ve seen used either in the learning theory literature or in practice.\nBeyond this, it also requires a specific parameter initialization and learning rate, both of which, to my knowledge, are far removed from the typical random initialization schemes and learning rate scaling rules used in practice and analyzed in theory. For instance, in Line 198, the first $m$ co-ordinates of the learning rate $\\eta$ is set as $5$, the next $n$ are set as $\\frac{1}{6N}$ while the next $m$ are set as $2000N$. This seems very very removed from any learning rate schedule either used in practice or analyzed in theory. This makes me severely doubt whether the result has any meaningful implication on the inherent hardness of the data debugging problem.\\\nIn addition, the training set and test data point are also constructed adversarially (the latter is perhaps this is to be expected I wouldn’t perceive that in isolation as a major weakness)\n\n2. **GTA Algorithm**: The correctness of the GTA algorithm is proved only for the linear case (which is honestly quite straightforward) and hinge-like losses for $\\beta \\geq 0$ and dimension $d=1$ (which is of limited interest as most statistical learning problems are high dimensional). This is particularly concerning as the paper does not perform any empirical evaluation of GTA. \n\n3. **Theorem 4.3** While the analysis for the hinge loss is certainly more interesting than Theorem 3.1, the result suffers from a key weakness that the data ordering is adversarially chosen (In particular, the positioning of $(x_c, y_c), (x_b, y_b), (x_a, y_a)$ is crucial to the reduction). It is well known in the theory of optimization that adversarial data orderings lead to provably worse convergence in practice [Safran and Shamir COLT 2020; Das, Scholkopf and Muehlebach NeurIPS 2022]. In fact, adversarial data ordering is even the basis of an attack on deep neural networks [see Shumailov et. al. “Manipulating SGD with Data Ordering Attacks” NeurIPS 2021].\\\nThe adversarial data ordering considered in the result differs both from the practical implementation of SGD which samples the data points in each epoch as per some random permutation [see Ahn and Sra NeurIPS 2020 and references therein] or the canonical version of SGD considered in theory where data indices are sampled uniformly with replacement [Bubeck 2015]. To the best of my understanding, the result does not hold for either of these commonly considered variants of SGD. Furthermore, the training data and test data is again, adversarially chosen. \n\n4. **No Analysis for Cross Entropy** : The paper does not contain any analysis for the binary entropy loss which is what is commonly used to train classifiers, further limiting the scope of the results. \n\n5. **Complete Lack of Empirical Evaluation**: While this wouldn’t be a weakness by itself, the fact that the theoretical results in the paper have limited applicability (as argued above) makes me quite concerned about the absence of empirical evaluation on real world settings, or, for a start, even toy-like settings where the data is drawn from plausible distributions, the learning rates and parameters are initialized as one would normally expect them to be, and SGD is run either with replacement or without replacement and not with an adversarial data ordering. \n\nWhile the paper studies a question which I found interesting, I believe the limited applicability of the theoretical results, the absence of experimental evaluation as well as the limited technical novelty of the proofs (the proofs, although crisply written, are based on straightforward complexity theoretic reductions and do not unearth any nontrivial mathematical insights regarding SGD or linear classifiers) makes me confidently feel that the paper is currently not ready for acceptance at NeurIPS.\n\nQUESTIONS:\n1. Can you show that Theorem 3.1 continues to hold under standard distributional initialization schemes for the learning rate and the initial parameter (e.g. normal or Xavier initialization.\n\n2. Can you construct a class of distributions such that, if your training samples are drawn i.i.d from it, your hardness results continue to hold with high probability (or for starters, even in expectation)\n\n3. Are your results amenable to smoothed analysis, i.e., if the data points, learning rate and initialization in your construction is perturbed by some oblivious noise, would your hardness result continue to hold? \n\n4. Can you comment on the applicability of your results for the cross entropy loss?\n\nLIMITATIONS:\nMentioned in Section C as per the checklist. Also refer to comments above in Weakness Section.", "TITLE": "Official Review", "RECOMMENDATION": 3, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2024-07-12"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper addresses the computational task (coined as \"data debugging\") of finding training data subsets that yield different test point predictions. The focus of the paper is the SGD learning algorithm with linear classifiers. The paper shows that:\n - For general loss functions (to transform yw^Tx to a loss value), the data debugging task is NP-hard. \n - For linear loss functions, the data debugging task can be solved in linear time.\n - For \"hinge-like\" loss functions, the data debugging task with more than two features is NP-hard.\n\nSTRENGTHS:\n- The proofs look correct\n- The proofs are creative and clever\n- Generally speaking, understanding the relationship between training data and model predictions is important\n\nWEAKNESSES:\nClarity and exposition:\n- Many of the proofs have \"magic constants\" which makes them harder to understand. The authors may consider generalizing some of the results.\n- The proofs look correct, but are not optimized for being easily read and understood in terms of logical flow or notation.\n- Similarly, it is hard to extract the intuition from the proofs.\n- The implications of results for the wider community are somewhat muddled: while the computational hardness of exactly finding \"bad\" training points according to a particular definition is interesting, it's unclear what the relationship is to scoring based methods is since any selection algorithm could be identified with a scoring method (output 1 on selected points, and -1 on the rest), and \"CSP-solvers\" and \"random algorithms\" are mentioned without any particular explanation/exploration.\n\nSignificance:\n- The loss function used to prove Theorem 3.1 is rather pathological. The derivative is zero at most places, but has a few intervals with derivatives with wildly varying orders of magnitude: N, 1, and 1/N. Reading through the proof, this pathological loss function seems critical and not easily removed. I would find it much more significant if Theorem 3.1 could be proved for convex loss functions, or similar.\n- The assumption of an adversarial training order in Theorem 4.3 seems unreasonably restrictive. The user is changing the dataset by removing points, why can't they change the training order too? Again, this piece seems critical to the proof, since without the adversarial training order, I think the constructed data debugging task would be trivially solvable by taking a gradient descent step on (x_c,y_c) first. Can the theorem be extended to the user choosing the training order? Furthermore, the practical problem of data selection/cleaning is with regards to the presence/absence of datapoints, not the training order which is an optimization consideration. Can the theorem be proved not for a specific optimization algorithm like SGD, but for the minimizer(s) of the loss instead? A unique minimizer (for the hinge-loss and convex losses more generally) could be guaranteed by adding a small strictly convex regularization term.\n\nQUESTIONS:\n- Is there a cleaner/clearer way to describe and prove the results?\n- For convex loss functions and without a fixed training order, is the data debugging task NP-hard?\n- For convex loss functions and assuming an oracle to compute the loss minimizer, is the data debugging task NP-hard?\n- Is there a typo in the definition of the hinge loss on line 133? I think the conditional logical expression should have a minus sign in front of the beta.\n\nLIMITATIONS:\nYes", "TITLE": "Official Review", "RECOMMENDATION": 3, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2024-07-27"}