Original: I MPROVING THE A CCURACY OF L EARNING E XAMPLE W EIGHTS FOR I MBALANCED C LASSIFICATION
Revised: I MPROVING THE A CCURACY OF L EARNING E XAMPLE W EIGHTS FOR I MBALANCED C LASSIFICATION

Original: Anonymous authors

Original: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: To solve the imbalanced classiﬁcation, methods of weighting examples haven been proposed.
Revised: To solve the imbalanced classiﬁcation, methods of weighting examples have been proposed.

Original: Recent work has studied to assign adaptive weights to training examples through learning mechanisms.
Revised: Recent work has studied to assign adaptive weights to training examples through learning mechanisms.

Original: Speciﬁcally, similar to classiﬁcation models, the weights are regarded as parameters that need to be learned.
Revised: Speciﬁcally, similar to classiﬁcation models, the weights are regarded as parameters that need to be learned.

Original: However, the algorithms in recent work use local information to approximately optimize the weights, which may lead to inaccurate learning of the weights.
Revised: However, the algorithms in recent work use local information to approximately optimize the weights, which may lead to inaccurate learning of the weights.

Original: In this work, we ﬁrst propose a novel mechanism of learning with a constraint, which can accurately train the weights and model.
Revised: In this work, we ﬁrst propose a novel mechanism of learning with a constraint, which can accurately train the weights and model.

Original: Then, we propose a combined method of our learning mechanism and the existing work, which can promote each other to perform better.
Revised: Then, we propose a combined method of our learning mechanism and the existing work, which can promote each other to perform better.

Original: Ourproposed method can be applied to any type of deep network model.
Revised: Our method can be applied to any type of deep network model.

Original: Experiments show that compared with the state-of-art algorithms, our method has signiﬁcant improvement in varieties of settings, including text and image classiﬁcation over different imbalance ratios, binary and multi-class classiﬁcation.
Revised: Experiments show that compared with state-of-the-art algorithms, our method has signiﬁcant improvement in varieties of settings, including text and image classiﬁcation over different imbalance ratios, binary and multi-class classiﬁcation.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Classiﬁcation is a fundamental task in machine learning, but in practical classiﬁcation applications, the number of examples among classes may differ greatly, even by several orders of magnitude.
Revised: Classiﬁcation is a fundamental task in machine learning, but in practical classiﬁcation applications, the number of examples among classes may differ greatly, even by several orders of magnitude.

Original: Standard learning methods train the classiﬁcation model on such an imbalanced data set, which makes the trained model biased.
Revised: Standard learning methods train the classiﬁcation model on such an imbalanced data set which makes the trained model biased.

Original: This bias is that the model will prefer the majority class and easily misclassify the minority class examples.
Revised: This bias is that the model will prefer the majority class and easily misclassify the minority class examples.

Original: This class-imbalance problem exits in many domains, such as Twitter spam detection (Li & Liu, 2018), named entity recognition (Grancharova et al., 2020) in text classiﬁcation, and object detection (Oksuz et al., 2020), video surveillance (Wu & Chang, 2003) in image classiﬁcation.
Revised: This class-imbalance problem exists in many domains, such as Twitter spam detection (Li & Liu, 2018), named entity recognition (Grancharova et al., 2020) in text classiﬁcation and object detection (Oksuz et al., 2020), video surveillance (Wu & Chang, 2003) in image classiﬁcation.

Original: There are very rich research lines on using the methods of weighting examples to solve the class imbalance problem.
Revised: There are very rich research lines on using the methods of weighting examples to solve the class imbalance problem.

Original: In general, the weight of the minority class is higher than that of the majority class, so that the bias towards the majority class is alleviated.
Revised: In general, the weight of the minority class is higher than that of the majority class, so that the bias towards the majority class is alleviated.

Original: Typically, the example weight value of each class is often set to inverse class frequency (Wang et al., 2017) or inverse square root of class frequency (Mahajan et al., 2018).
Revised: Typically, the example weight value of each class is often set to inverse class frequency (Wang et al., 2017) or inverse square root of class frequency (Mahajan et al., 2018).

Original: However, the example weights in these methods are designed empirically, hence they can not be adapted to different datasets and may perform poorly.
Revised: However, the example weights in these methods are designed empirically, hence they can not be adapted to different datasets and may perform poorly.

Original: Recent work has studied the methods of using learning mechanisms to adaptively calculate the example weights.
Revised: Recent work has studied the methods of using learning mechanisms to adaptively calculate the example weights.

Original: Ren et al.
Revised: Ren et al.

Original: (2018) propose to use a meta-learning paradigm (Hospedales et al., 2020) to learn the weights.
Revised: (2018) propose to use a meta-learning paradigm (Hospedales et al., 2020) to learn the weights.

Original: In this method, the example weights can be regarded as a meta-learner and the classiﬁcation model is a learner.
Revised: In this method, the example weights can be regarded as a meta-learner and the classiﬁcation model is a learner.

Original: The meta-learner guides the learner to learn by weighting the example loss in the model optimization objective.
Revised: The meta-learner guides the learner to learn by weighting the example loss in the model optimization objective.

Original: More speciﬁcally, the model objective is to get the optimal model that minimizes the example-weighted loss of the imbalanced training set.
Revised: More speciﬁcally, the model objective is to get the optimal model that minimizes the example-weighted loss of the imbalanced training set.

Original: Obviously, different weights will affect the performance of the optimal model.
Revised: Obviously, different weights will affect the performance of the optimal model.

Original: Which weight values make the corresponding optimal model the best?
Revised: Which weight values make the corresponding optimal model the best?

Original: This method collects a small balanced validation set and evaluates the weight values through the validation performance of the model.
Revised: This method collects a small balanced validation set and evaluates the weight values through the validation performance of the model.

Original: Therefore, the meta-learner objective, namely meta-objective, gives the best weights that make the optimal model minimize the loss of the balanced validation set.
Revised: Therefore, the meta-learner objective, namely meta-objective, gives the best weights that make the optimal model minimize the loss of the balanced validation set.

Original: This optimization problem is challenging.
Revised: This optimization problem is challenging.

Original: The key is that, in the meta-objective , the weights indirectly affect the loss through the optimal model, so it is necessary to clearly deﬁne the dependence of the weights and the optimal model in the model objective for optimizing the weights.
Revised: The key is that, in the meta-objective , the weights indirectly affect the loss through the optimal model, so it is necessary to clearly deﬁne the dependence of the weights and the optimal model in the model objective for optimizing the weights.

Original: However, it is expensive to get this dependence through multiple gradient descent steps in the model objective .
Revised: However, it is expensive to get this dependence through multiple gradient descent steps in the model objective .

Original: Ren et al.
Revised: Ren et al.

Original: (2018) propose an online approximation method to estimate this dependence, that is, the method trains the model using a gradient descent step in the model objective and then can determine the relationship between the weights and the trained model in this step.
Revised: (2018) propose an online approximation method to estimate this dependence, that is, the method trains the model using a gradient descent step in the model objective and then can determine the relationship between the weights and the trained model in this step.

Original: Hu et al.
Revised: Hu et al.

Original: (2019) propose to update the example weights iteratively to replace the re-estimation proposed by Ren et al.
Revised: (2019) propose to update the example weights iteratively to replace the re-estimation proposed by Ren et al.

Original: (2018), but also adopt the local approximation to optimize the weights.
Revised: (2018), but also adopt the local approximation to optimize the weights.

Original: However, this approximation only considers the inﬂuence of the weights on the trained model in a short term (in a descent step), resulting in inaccurate learning of the weights.
Revised: However, this approximation only considers the inﬂuence of the weights on the trained model in a short term (in a descent step), resulting in inaccurate learning of the weights.

Original: In this paper, we ﬁrstly propose a novel learning mechanism that can obtain the precise relationship between the weights and the trained model in the model objective , so that the weights and model can be optimized more accurately.
Revised: In this paper, we ﬁrstly propose a novel learning mechanism that can obtain the precise relationship between the weights and the trained model in the model objective , so that the weights and model can be optimized more accurately.

Original: In this mechanism, we convert the model objective into an equation of the current model and weights.
Revised: In this mechanism, we convert the model objective into an equation of the current model and weights.

Original: Then, we derive their relationship from this equation, and then we use this relationship to optimize the weights in the meta-objective and update the corresponding model.
Revised: Then, we derive their relationship from this equation, and then we use this relationship to optimize the weights in the meta-objective and update the corresponding model.

Original: Since this optimization process always satisﬁes this equation, we call it learning with a constraint.
Revised: Since this optimization process always satisﬁes this equation, we call it learning with a constraint.

Original: However, the mechanism only uses the model objective to calculate the relationship but does not optimize the model for the model objective .
Revised: However, the mechanism only uses the model objective to calculate the relationship but does not optimize the model for the model objective .

Original: To solve this problem, we integrate the method proposed by Hu et al.
Revised: To solve this problem, we integrate the method proposed by Hu et al.

Original: into our learning mechanism and propose a combined algorithm.
Revised: into our learning mechanism and propose a combined algorithm.

Original: In this algorithm, the method of Hu et al.
Revised: In this algorithm, the method of Hu et al.

Original: can help to further optimize the model in the model objective , and our learning mechanism can make the weights and model learn more accurately.
Revised: can help to further optimize the model in the model objective , and our learning mechanism can make the weights and model learn more accurately.

Original: Finally, we conduct a lot of experiments to validate the effectiveness of this algorithm.
Revised: Finally, we conduct a lot of experiments to validate the effectiveness of this algorithm.

Original: The experimental settings include (1) different domains, namely text and image classiﬁcation; (2) different scenarios, namely binary and multi-class classiﬁcation, (3) different imbalance ratios.
Revised: The experimental settings include (1) different domains, namely text and image classiﬁcation; (2) different scenarios, namely binary and multi-class classiﬁcation, (3) different imbalance ratios.

Original: The results show that our algorithm not only outperforms the state-of-art method in data weighting but also performs best among other comparison methods in varieties of settings.
Revised: The results show that our algorithm not only outperforms the state-of-the-art (SOTA) method in data weighting but also performs best among other comparison methods in varieties of settings.

Original: The remainder of this paper is organized as follows.
Revised: The remainder of this paper is organized as follows.

Original: Section 2 introduces preliminaries of the two objectives and the existing method proposed by Hu et al.
Revised: Section 2 introduces preliminaries of the two objectives and the main idea of Hu et al.

Original: is presented as well.

Original: Section 3 presents our mechanism of learning with a constraint and the combined algorithm.
Revised: Section 3 presents our mechanism of learning with a constraint and the combined algorithm.

Original: Section 4 presents the experimental settings and evaluation results.
Revised: Section 4 presents the experimental settings and evaluation results.

Original: Section 5 summarizes the related work. Finally, Section 6 concludes this paper.
Revised: Section 5 summarizes the related work and Section 6 concludes this paper.

Original:  P RELIMINARIES AND N OTATIONS
Revised:  P RELIMINARIES AND N OTATIONS

Original: Let ( x, y ) be the input and target pair.
Revised: Let ( x, y ) be the input and target pair.

Original: For example, in image classiﬁcation, x is the image and y is the image label.
Revised: For example, in image classiﬁcation, x is the image and y is the image label.

Original: Let D train denote the train set, and D train = { ( x i , y i ) , 1 (cid:54) i (cid:54) N } .
Revised: Let D train denote the train set, and D train = { ( x i , y i ) , 1 (cid:54) i (cid:54) N } .

Original: Let D val be a small balanced validation set, and D val = { ( x i , y i ) , 1 (cid:54) i (cid:54) M } where M (cid:28) N .
Revised: Let D val be a small balanced validation set, and D val = { ( x i , y i ) , 1 (cid:54) i (cid:54) M } where M (cid:28) N .

Original: We denote neural network model as Φ( x, θ ) , where θ ∈ R K is the model parameter.
Revised: We denote neural network model as Φ( x, θ ) , where θ ∈ R K is the model parameter.

Original: The predicted value ˆ y =
Revised: The predicted value ˆ y =

Original: Φ( x, θ ) .
Revised: Φ( x, θ ) .

Original: We use loss function f
Revised: We use loss function f

Original: (ˆ y, y ) to measure the difference between predicted value ˆ y and target value y , and the loss function of data x i is deﬁned as f i ( θ ) for clarity.
Revised: (ˆ y, y ) to measure the difference between predicted value ˆ y and target value y , and the loss function of data x i is deﬁned as f i ( θ ) for clarity.

Original: Standard training method is to minimize the expected loss on the training set: (cid:80) Ni =
Revised: Standard training method is to minimize the expected loss on the training set: (cid:80) Ni =

Original: 1 f i ( θ ) , and each example has same weight.
Revised: 1 f i ( θ ) , and each example has same weight.

Original: However, for an imbalanced data set, the model obtained by this method will be biased towards the majority class.
Revised: However, for an imbalanced data set, the model obtained by this method will be biased towards the majority class.

Original: Here, we aim to learn a model parameter θ that is fair to the minority class and the majority class by minimizing the weighted loss of training examples:
Revised: Here, we aim to learn a model parameter θ that is fair to the minority class and the majority class by minimizing the weighted loss of training examples:

Original: [Equation]
Revised: [Equation]

Original: where w = ( w 1 , ..., w N ) T is the weights of all training examples.
Revised: where w = ( w 1 , ..., w N ) T is the weights of all training examples.

Original: We use L train to represent the weighted loss on the training set D train .
Revised: We use L train to represent the weighted loss on the training set D train .

Original: For a given w , we can obtain the corresponding optimal θ ∗ from Eq.1.
Revised: For a given w , we can obtain the corresponding optimal θ ∗ from Eq.1.

Original: Thus, there is a dependence between θ ∗ and w and we write it as θ ∗ =
Revised: Thus, there is a dependence between θ ∗ and w and we write it as θ ∗ =

Original: θ ∗ ( w ) .
Revised: θ ∗ ( w ) .

Original: Learning to Weight Examples
Revised: Learning to Weight Examples

Original: The recent work (Ren et al., 2018) proposed a method of learning the weights of training examples.
Revised: The recent work (Ren et al., 2018) proposed a method of learning the weights of training examples.

Original: In this method, the optimal w is to make the model parameter θ ∗ obtained from Eq.1 minimize the loss on a balanced validation set.
Revised: In this method, the optimal w is to make the model parameter θ ∗ obtained from Eq.1 minimize the loss on a balanced validation set.

Original: It means that this model performs well on a balanced validation set, and it can fairly distinguish examples from different classes.
Revised: It means that this model performs well on a balanced validation set, and it can fairly distinguish examples from different classes.

Original: Formally, the optimal w is given as
Revised: Formally, the optimal w is given as

Original: [Equation]
Revised: [Equation]

Original: where the superscript v stands for validation set.
Revised: where the superscript v stands for validation set.

Original: Let L val be the loss on the validation set D val .
Revised: Let L val be the loss on the validation set D val .

Original: Learning the Parameters The recent work (Hu et al., 2019) introduced an algorithm of solving the model parameter θ ∗ and weight w ∗ .
Revised: Learning the Parameters The recent work (Hu et al., 2019) introduced an algorithm of solving the model parameter θ ∗ and weight w ∗ .

Original: The algorithm optimizes θ and w alternately until convergence.
Revised: The algorithm optimizes θ and w alternately until convergence.

Original: In each iteration, the algorithm utilizes a gradient descent step in Eq.1 to approximate the relationship between θ and w , and then calculates the gradient ∇ w L val and ∇ θ L train to update w and θ respectively.
Revised: In each iteration, the algorithm utilizes a gradient descent step in Eq.1 to approximate the relationship between θ and w , and then calculates the gradient ∇ w L val and ∇ θ L train to update w and θ respectively.

Original: More speciﬁcally, at the t -th iteration, the algorithm ﬁrst calculates the approximate relationship between θ and w through the t -th gradient descent step in Eq.1.
Revised: More speciﬁcally, at the t -th iteration, the algorithm ﬁrst calculates the approximate relationship between θ and w through the t -th gradient descent step in Eq.1.

Original: We deﬁne a matrix F ( θ ) =
Revised: We deﬁne a matrix F ( θ ) =

Original: ( ∇ f 1 ( θ ) , ..., ∇ f N ( θ )) , whose column vector represents the derivative of f i ( θ ) with respect to θ , so we calculate the derivative of ∇ θ L train with respect to θ as ∇ θ L train =
Revised: ( ∇ f 1 ( θ ) , ..., ∇ f N ( θ )) , whose column vector represents the derivative of f i ( θ ) with respect to θ , so we calculate the derivative of ∇ θ L train with respect to θ as ∇ θ L train =

Original: F ( θ ) w .
Revised: F ( θ ) w .

Original: Then, the t -th gradient descent step of θ is given as
Revised: Then, the t -th gradient descent step of θ is given as

Original: [Equation]
Revised: [Equation]

Original: where η θ is the descent step size on θ .
Revised: where η θ is the descent step size on θ .

Original: In order to avoid very expensive calculations, the algorithm ignores the inﬂuence of w on θ t .
Revised: In order to avoid very expensive calculations, the algorithm ignores the inﬂuence of w on θ t .

Original: Therefore, in the single gradient descent step, ˆ θ t +1 linearly depends on w .
Revised: Therefore, in the single gradient descent step, ˆ θ t +1 linearly depends on w .

Original: Then, based on this linear dependence, the algorithm can calculate the gradient ∇ w L val and uses gradient descent to update w , and then updates θ again to make it perform better on validation set.
Revised: Then, based on this linear dependence, the algorithm can calculate the gradient ∇ w L val and uses gradient descent to update w , and then updates θ again to make it perform better on validation set.

Original: Substituting the updated ˆ θ t +1 into Eq.2, we have L val =
Revised: Substituting the updated ˆ θ t +1 into Eq.2, we have L val =

Original: 1 M (cid:80) Mi
Revised: 1 M (cid:80) Mi

Original: =

Revised: =

Original: f vi (ˆ θ t +1 ( w )) .
Revised: f vi (ˆ θ t +1 ( w )) .

Original: We can observe that the w acts on ˆ θ t
Revised: We can observe that the w acts on ˆ θ t

Original: +

Revised: +

Original: and then affects L val .
Revised: and then affects L val .

Original: Thus, combining Eq.3, we can calculate the gradient ∇ 
Revised: Thus, combining Eq.3, we can calculate the gradient ∇ w [Equation] = ( ∇ [Equation]

Revised: ˆ

Original: [Equation]
Revised: [Equation]

Revised: +

Revised: [Equation]

Revised: [Equation]

Revised: L val =

Revised: [Equation]

Original: =
Revised: F ( θ [Equation] [Equation] ∇

Original: [Equation]
Revised: [Equation]

Original:  L val , so the update on w at t step is given as
Revised: 1 L val , so the update on w at t step is given as

Original: [Equation]
Revised: [Equation]

Original: 4) where η w is the descent step size on w .
Revised: 4) where η w is the descent step size on w .

Original: According to gradient descent theory, when η w is appropriately small, L val ( w t +1 ) ≤ L val ( w t ) .
Revised: According to gradient descent theory, when η w is appropriately small, L val ( w t +1 ) ≤ L val ( w t ) .

Original: This means using w t +1 to update θ performs better than w t .
Revised: This means using w t +1 to update θ performs better than w t .

Original: Therefore, the algorithm substitutes the updated w t +1 into Eq.3 and obtain the new update on θ
Revised: Therefore, the algorithm substitutes the updated w t +1 into Eq.3 and obtain the new update on θ

Original: [Equation]
Revised: [Equation]

Original: 5) where θ t +1 satisﬁes L val ( θ t +1 ) ≤ L val (ˆ θ t +1 ) , that is, θ t +1 have better validation performance than ˆ θ t +1 .
Revised: 5) where θ t +1 satisﬁes L val ( θ t +1 ) ≤ L val (ˆ θ t +1 ) , that is, θ t +1 have better validation performance than ˆ θ t +1 .

Original: Finally, the algorithm repeatedly calculates Eq.3, 4 and 5 and alternately optimizes θ and w until convergence.
Revised: Finally, the algorithm repeatedly calculates Eq.3, 4 and 5 and alternately optimizes θ and w until convergence.

Original:  N EW M ETHOD OF L EARNING THE P ARAMETERS
Revised:  N EW M ETHOD OF L EARNING THE P ARAMETERS

Original: In this section, we introduce a new method to learn the model parameter θ ∗ and weight w ∗ in Eq. and Eq.2.
Revised: In this section, we introduce a new method to learn the model parameter θ ∗ and weight w ∗ in Eq. and Eq.2.

Original: First, in Section 3.1, we propose to learn θ and w with a constraint, which can accurately optimize θ and w .
Revised: First, in Section 3.1, we propose to learn θ and w with a constraint, which can accurately optimize θ and w .

Original: Then, in Section 3.2, we propose a combined method to train θ and w to make the model parameter θ have better performance.
Revised: Then, in Section 3.2, we propose a combined method to train θ and w to make the model parameter θ have better performance.

Original: 3. L EARNING W ITH A C ONSTRAINT
Revised: 3. L EARNING W ITH A C ONSTRAINT

Original: In the section, we ﬁrst analyze the difﬁculty of solving θ ∗ and w ∗ .
Revised: In the section, we ﬁrst analyze the difﬁculty of solving θ ∗ and w ∗ .

Original: Gradient-based optimization is a commonly used method in machine learning.
Revised: Gradient-based optimization is a commonly used method in machine learning.

Original: Thus, we ﬁrst need to calculate the gradient ∇ θ L train and ∇ w L val .
Revised: Thus, we ﬁrst need to calculate the gradient ∇ θ L train and ∇ w L val .

Original: Based on Eq.2, we have ∇ w L val =
Revised: Based on Eq.2, we have ∇ w L val =

Original: ( ∇ w θ ∗ ) T ∇ θ ∗ L val .
Revised: ( ∇ w θ ∗ ) T ∇ θ ∗ L val .

Original: However, it is difﬁcult to explicitly give the form of function θ ∗ ( w ) , resulting in ∇ w L val cannot be calculated directly.
Revised: However, it is difﬁcult to explicitly give the form of function θ ∗ ( w ) , resulting in ∇ w L val cannot be calculated directly.

Original: The previous work obtained the relationship between θ and w through the gradient descent process of θ , and only considered the inﬂuence of w on θ in a single gradient descent step.
Revised: The previous work obtained the relationship between θ and w through the gradient descent process of θ , and only considered the inﬂuence of w on θ in a single gradient descent step.

Original: Based on this relationship, calculating the gradient and updating the parameter is not precise.
Revised: Based on this relationship, calculating the gradient and updating the parameter is not precise.

Original: Here, we obtain the relationship between θ and w from a new perspective.
Revised: Here, we obtain the relationship between θ and w from a new perspective.

Original: First, we observe the gradient ∇ θ L train , that is,
Revised: First, we observe the gradient ∇ θ L train , that is,

Original: [Equation]
Revised: [Equation]

Original: Input : The network model parameter θ
Revised: Input : The network model parameter θ

Original: The weight of training examples w
Revised: The weight of training examples w

Original: Training set D train ; Validation set D val
Revised: Training set D train ; Validation set D val

Original: The number of iterations of the combination method T
Revised: The number of iterations of the combination method T

Original: The number of iterations of our method T (cid:48) 1 Initialize model parameter θ and weight w 2 for t = 0 ...
Revised: The number of iterations of our method T (cid:48) 1 Initialize model parameter θ and weight w 2 for t = 0 ...

Original: T − 1 do
Revised: T − 1 do

Original: Calculate the relationship between θ and w on D train though Eq.
Revised: Calculate the relationship between θ and w on D train though Eq.

Original: Optimize w on D val though Eq.
Revised: Optimize w on D val though Eq.

Original: Update θ though Eq.
Revised: Update θ though Eq.

Original: for t (cid:48)
Revised: for t (cid:48)

Original: = 

Revised: =

Original: T (cid:48) − 1 do
Revised: T (cid:48) − 1 do

Original: Calculate the derivative ∇ w θ on D train though Eq.
Revised: Calculate the derivative ∇ w θ on D train though Eq.

Original: Optimize w on D val though Eq.
Revised: Optimize w on D val though Eq.

Original: Update θ though Eq.
Revised: Update θ though Eq.

Original: Output: Trained model parameter θ ∗ and weight w ∗ where c is the gradient value.
Revised: Output: Trained model parameter θ ∗ and weight w ∗ where c is the gradient value.

Original: We can see that changing the value of w can ﬁnd corresponding θ to satisfy Eq.6.
Revised: We can see that changing the value of w can ﬁnd corresponding θ to satisfy Eq.6.

Original: It means that there is a functional relationship between θ and w in Eq.6.
Revised: It means that there is a functional relationship between θ and w in Eq.6.

Original: Because all θ and w satisfying this equation have the same value of ∇ θ L train , we also call Eq.6 a constraint of θ and w .
Revised: Because all θ and w satisfying this equation have the same value of ∇ θ L train , we also call Eq.6 a constraint of θ and w .

Original: In particular, the optimal model parameter θ ∗ and w satisfy the constraint: F ( θ ∗ ) w = 0 .
Revised: In particular, the optimal model parameter θ ∗ and w satisfy the constraint: F ( θ ∗ ) w = 0 .

Original: Then, we can make use of the constraint to derive a precise relationship between θ and w .
Revised: Then, we can make use of the constraint to derive a precise relationship between θ and w .

Original: Our network model may be very complex, and we cannot explicitly give the functional form of θ and w according to the constraint.
Revised: Our network model may be very complex, and we cannot explicitly give the functional form of θ and w according to the constraint.

Original: However, by applying the implicit function theorem, the derivative of θ with respect to w in Eq.6 can be obtained as follow
Revised: However, by applying the implicit function theorem, the derivative of θ with respect to w in Eq.6 can be obtained as follow

Original: [Equation]
Revised: [Equation]

Original: where H ∈ R K × R K is the Hessian matrix, namely, the second derivative of L train with respect to θ .
Revised: where H ∈ R K × R K is the Hessian matrix, namely, the second derivative of L train with respect to θ .

Original: However, calculating an exact Hessian matrix is very expensive.
Revised: However, calculating an exact Hessian matrix is very expensive.

Original: Especially nowadays network models have a huge amount of parameters.
Revised: Especially nowadays network models have a huge amount of parameters.

Original: In addition, in this case, we require the inverse of H , rather than H itself.
Revised: In addition, in this case, we require the inverse of H , rather than H itself.

Original: Therefore, we adopt diagonal approximation to evaluate H (Bishop, 2006).
Revised: Therefore, we adopt diagonal approximation to evaluate H (Bishop, 2006).

Original: In other words, we only need to calculate the diagonal elements of H .
Revised: In other words, we only need to calculate the diagonal elements of H .

Original: Furthermore, it is trivial to calculate the inverse by taking the reciprocal of the diagonal elements.
Revised: Furthermore, it is trivial to calculate the inverse by taking the reciprocal of the diagonal elements.

Original: Let h ∈ R K be the reciprocal of the diagonal elements of H .
Revised: Let h ∈ R K be the reciprocal of the diagonal elements of H .

Original: Then, the derivative is evaluated as
Revised: Then, the derivative is evaluated as

Original: [Equation]
Revised: [Equation]

Original: Next, we can make use of the derivative to calculate the gradient ∇ w L val , and then update w and θ .
Revised: Next, we can make use of the derivative to calculate the gradient ∇ w L val , and then update w and θ .

Original: The update process always satisﬁes the constraint of Eq.6, so we call it learning with a constraint.
Revised: The update process always satisﬁes the constraint of Eq.6, so we call it learning with a constraint.

Original: Combining Eq.7, we have ∇ w L val =
Revised: Combining Eq.7, we have ∇ w L val =

Original: − F ( θ ) T diag ( h ) ∇ θ L val .
Revised: − F ( θ ) T diag ( h ) ∇ θ L val .

Original: Thus, the update of w is
Revised: Thus, the update of w is

Original: [Equation]
Revised: [Equation]

Original: where η (cid:48) w is the step size.
Revised: where η (cid:48) w is the step size.

Original: Then, we use the updated w (cid:48) to calculate the corresponding θ (cid:48) in the constraint.
Revised: Then, we use the updated w (cid:48) to calculate the corresponding θ (cid:48) in the constraint.

Original: Since we do not know the explicit functional form of θ and w in Eq.6, we use the ﬁrst order derivative to approximate θ (cid:48) .
Revised: Since we do not know the explicit functional form of θ and w in Eq.6, we use the ﬁrst order derivative to approximate θ (cid:48) .

Original: Combing Eq.7, θ (cid:48) is evaluated as
Revised: Combing Eq.7, θ (cid:48) is evaluated as

Original: [Equation]
Revised: [Equation]

Original: Finally, under the condition of satisfying the constraint, we repeatedly optimize w and θ , corresponding to Eq.8 and Eq.9, until convergence.
Revised: Finally, under the condition of satisfying the constraint, we repeatedly optimize w and θ , corresponding to Eq.8 and Eq.9, until convergence.

Original: The detailed proof of this convergence can be found in Theorem 1 in Appendix A.2.
Revised: The detailed proof of this convergence can be found in Theorem 1 in Appendix A.2.

Original: 3. L EARNING I N A C OMBINED W AY AND I MPLEMENTATION
Revised: 3. L EARNING I N A C OMBINED W AY AND I MPLEMENTATION

Original: The method we proposed in Section3.1 still has a shortcoming.
Revised: The method we proposed in Section3.1 still has a shortcoming.

Original: In the method, we make use of the gradient ∇ θ L train of Eq.1 to obtain a constraint ∇ θ L train =
Revised: In the method, we make use of the gradient ∇ θ L train of Eq.1 to obtain a constraint ∇ θ L train =

Original: c , and then calculate the solution of w and θ under the constraint.
Revised: c , and then calculate the solution of w and θ under the constraint.

Original: However, this method only ensures that the solution is optimal in Eq.
Revised: However, this method only ensures that the solution is optimal in Eq.

Original: [Table]

Original: [Table]

Original: under the constraint, and cannot guarantee that the solution of θ is optimal in Eq.1.
Revised: under the constraint, and cannot guarantee that the solution of θ is optimal in Eq.1.

Original: Because our method only use Eq.1 to obtain the constraint, but not to optimize θ for Eq.1, and when c (cid:54) = 0 , the solution of θ is not optimal in Eq.1.
Revised: Because our method only use Eq.1 to obtain the constraint, but not to optimize θ for Eq.1, and when c (cid:54) = 0 , the solution of θ is not optimal in Eq.1.

Original: In order to calculate the better solution, our method needs to be combined with another algorithm that can make θ reach the optimal in Eq.1.
Revised: In order to calculate the better solution, our method needs to be combined with another algorithm that can make θ reach the optimal in Eq.1.

Original: The method of Hu et al.
Revised: The method of Hu et al.

Original: in Section2 is a more appropriate choice, rather than directly updating θ using the gradient ∇ θ L train .
Revised: in Section2 is a more appropriate choice, rather than directly updating θ using the gradient ∇ θ L train .

Original: Because it will ﬁrst adjust w and then update θ based on the new w .
Revised: Because it will ﬁrst adjust w and then update θ based on the new w .

Original: It is explained in Section2 that θ obtained in this way has a better validation performance than θ directly using gradient descent.
Revised: It is explained in Section2 that θ obtained in this way has a better validation performance than θ directly using gradient descent.

Original: Therefore, we propose a way to learn θ and w by combining our method in Section3.1 with the method (Hu et al.) in Section2.
Revised: Therefore, we propose a way to learn θ and w by combining our method in Section3.1 with the method (Hu et al.) in Section2.

Original: In this way, we alternately use these two methods to learn θ and w .
Revised: In this way, we alternately use these two methods to learn θ and w .

Original: In each iteration, we ﬁrst update θ and w using the method (Hu et al.).
Revised: In each iteration, we ﬁrst update θ and w using the method (Hu et al.).

Original: It can make θ reduce the value of L train and approach the optimal in Eq.1, while θ also reduces L val and perform well on validation set.
Revised: It can make θ reduce the value of L train and approach the optimal in Eq.1, while θ also reduces L val and perform well on validation set.

Original: Then, we optimize θ and w using our method until convergence, so that θ further reduces L val and has the best veriﬁcation performance among all θ with the same gradient ∇ θ L train .
Revised: Then, we optimize θ and w using our method until convergence, so that θ further reduces L val and has the best veriﬁcation performance among all θ with the same gradient ∇ θ L train .

Original: This combined way can overcome the shortcomings of each method.
Revised: This combined way can overcome the shortcomings of each method.

Original: On the one hand,the method (Hu et al.) can use the gradient ∇ θ L train to update θ and make θ close to the optimal in Eq.1.
Revised: On the one hand,the method (Hu et al.) can use the gradient ∇ θ L train to update θ and make θ close to the optimal in Eq.1.

Original: It makes up for the shortcoming that our method cannot optimize Eq.1.
Revised: It makes up for the shortcoming that our method cannot optimize Eq.1.

Original: On the other hand, the method (Hu et al.) only considers the inﬂuence of w on θ in a single gradient descent step, and then uses this approximation to optimize Eq.2.
Revised: On the other hand, the method (Hu et al.) only considers the inﬂuence of w on θ in a single gradient descent step, and then uses this approximation to optimize Eq.2.

Original: Hence, θ obtained by the method (Hu et al.)
Revised: Hence, θ obtained by the method (Hu et al.)

Original: may not be optimal for
Revised: may not be optimal for

Original: Eq.2.
Revised: Eq.2.

Original: Our method can make use of a constraint to derive an accurate functional relationship between θ and w .
Revised: Our method can make use of a constraint to derive an accurate functional relationship between θ and w .

Original: Thus, by optimizing θ through our method, a better solution can be obtained.
Revised: Thus, by optimizing θ through our method, a better solution can be obtained.

Original: This combination algorithm is listed in Algorithm 1.
Revised: This combination algorithm is listed in Algorithm 1.

Original: It takes T iterations to alternately use two methods to optimize θ and w .
Revised: It takes T iterations to alternately use two methods to optimize θ and w .

Original: In t -th iteration, it ﬁrst adopts the method (Hu et al.)
Revised: In t -th iteration, it ﬁrst adopts the method (Hu et al.)

Original: to update w and θ (lines 3-5), and then it uses our method to optimize w and θ repeatedly T times (lines 6-9), making θ converges under the current constraint.
Revised: to update w and θ (lines 3-5), and then it uses our method to optimize w and θ repeatedly T times (lines 6-9), making θ converges under the current constraint.

Original: Finally, it outputs the trained model parameter θ ∗ and weight w ∗ .
Revised: Finally, it outputs the trained model parameter θ ∗ and weight w ∗ .

Original: The proof of convergence of the Algorithm 1 can be found in Theorem 2 in Appendix
Revised: The proof of convergence of the Algorithm 1 can be found in Theorem 2 in Appendix

Original: A.2.
Revised: A.2.

Original: In addition, we discuss the convergence rate of Algorithm 1.
Revised: In addition, we discuss the convergence rate of Algorithm 1.

Original: According to the conclusion in the paper (Ren et al., 2018), when we take T steps to update the parameter θ through the method (Hu et al.), it can achieve (cid:107) ∇ θ L val (cid:107)≤ O ( 1 √ T ) where (cid:107) ∇ θ L val (cid:107) is the update precision of parameter θ .
Revised: According to the conclusion in the paper (Ren et al., 2018), when we take T steps to update the parameter θ through the method (Hu et al.), it can achieve (cid:107) ∇ θ L val (cid:107)≤ O ( 1 √ T ) where (cid:107) ∇ θ L val (cid:107) is the update precision of parameter θ .

Original: For the method in Section 3.1, achieving the same precision requires O ( √ T ) steps.
Revised: For the method in Section 3.1, achieving the same precision requires O ( √ T ) steps.

Original: More detailed proofs are in Theorem 3 in Appendix A.3.
Revised: More detailed proofs are in Theorem 3 in Appendix A.3.

Original: Therefore, as the combined method, Algorithm 1 needs
Revised: Therefore, as the combined method, Algorithm 1 needs

Original: T × O ( √ T ) =
Revised: T × O ( √ T ) =

Original: O ( T 32 ) to converge.
Revised: O ( T 32 ) to converge.

Original:  E XPERIMENTS
Revised:  E XPERIMENTS

Original: In this section, we perform extensive experiments to validate the effectiveness of our method.
Revised: In this section, we perform extensive experiments to validate the effectiveness of our method.

Original: First, we describe the experimental setup in detail.
Revised: First, we describe the experimental setup in detail.

Original: Second, we compare different methods in two domains: text and image classiﬁcation and in two situations: binary classiﬁcation and multi-class classiﬁcation.
Revised: Second, we compare different methods in two domains: text and image classiﬁcation and in two situations: binary classiﬁcation and multi-class classiﬁcation.

Original: Third, we design experiments to study the performance of our method in different imbalance ratios.
Revised: Third, we design experiments to study the performance of our method in different imbalance ratios.

Original: Moreover, we evaluate the performance of our methods with different metrics on a large-scale data set in Appendix A.1.
Revised: Moreover, we evaluate the performance of our methods with different metrics on a large-scale data set in Appendix A.1.

Original: 4. E XPERIMENTAL S ETUP
Revised: 4. E XPERIMENTAL S ETUP

Original: Models.
Revised: Models.

Original: We choose two network models for text and image classiﬁcation.
Revised: We choose two network models for text and image classiﬁcation.

Original: Speciﬁcally, in text classiﬁcation, we use the BERT (base, uncased) model (Devlin et al., 2018) to extract the 768- [Table] dimensional representation of text data (Xiao, 2018) and then use a simple 4-layer fully connected network (FCN) for classiﬁcation.
Revised: Speciﬁcally, in text classiﬁcation, we use the BERT (base, uncased) model (Devlin et al., 2018) to extract the 768dimensional representation of text data (Xiao, 2018) and then use a simple 4-layer fully connected network (FCN) for classiﬁcation.

Original: The FCN model is given as Table 1.
Revised: The FCN model is given as Table 1.

Original: The pair of numbers in brackets respectively indicate the sizes of input and output of the linear layer.
Revised: The pair of numbers in brackets respectively indicate the sizes of input and output of the linear layer.

Original: In addition, the ﬁrst two layers apply rectiﬁed linear unit activation (ReLU) function to avoid the vanishing gradient problem during training, and the third layer uses a nonlinear activation function (Tanh) to enhance the model learning ability.
Revised: In addition, the ﬁrst two layers apply rectiﬁed linear unit activation (ReLU) function to avoid the vanishing gradient problem during training, and the third layer uses a nonlinear activation function (Tanh) to enhance the model learning ability.

Original: The last layer is the classiﬁcation layer, in which the size of output depends on the number of classes in a classiﬁcation task.
Revised: The last layer is the classiﬁcation layer, in which the size of output depends on the number of classes in a classiﬁcation task.

Original: In image classiﬁcation, we use the ALLCNN-C network model that is a sequence of 9 convolution layers.
Revised: In image classiﬁcation, we use the ALLCNN-C network model that is a sequence of 9 convolution layers.

Original: Noting that our method does not rely on the classiﬁcation model, and can also be applied to other models. 
Revised: Noting that our method does not rely on the classiﬁcation model, and can also be applied to other models. [Table] [Table]

Original: Data Sets and Model Preparation.
Revised: Data Sets and Model Preparation.

Original: We choose 4 data sets for text and image classiﬁcation, and we use part of training examples in the data sets to prepare for the subsequent training of the models.
Revised: We choose 4 data sets for text and image classiﬁcation, and we use part of training examples in the data sets to prepare for the subsequent training of the models.

Original: The information of the four data sets we used is shown in Table 2.
Revised: The information of the four data sets we used is shown in Table 2.

Original: In text classiﬁcation, we use two popular benchmark datasets.
Revised: In text classiﬁcation, we use two popular benchmark datasets.

Original: We use the SST-2 sentiment analysis benchmark (Socher et al., 2013) for binary classiﬁcation, and use the SST-5 sentence sentiment (Socher et al., 2013) with 5 categories for multi-class classiﬁcation.
Revised: We use the SST-2 sentiment analysis benchmark (Socher et al., 2013) for binary classiﬁcation, and use the SST-5 sentence sentiment (Socher et al., 2013) with 5 categories for multi-class classiﬁcation.

Original: In image classiﬁcation, we adopt the commonly-used
Revised: In image classiﬁcation, we adopt the commonly-used

Original: CIFAR10 (Schneider et al., 2019) for multi-class classiﬁcation experiment and select the examples of class 0 and 1 from CIFAR100 (Schneider et al., 2019) to form a data set for binary classiﬁcation.
Revised: CIFAR10 (Schneider et al., 2019) for multi-class classiﬁcation experiment and select the examples of class 0 and 1 from CIFAR100 (Schneider et al., 2019) to form a data set for binary classiﬁcation.

Original: To make subsequent experiments on strong models, we use part of training examples to ﬁne-tune the BERT and pre-train the ALL-CNN-C model respectively.
Revised: To make subsequent experiments on strong models, we use part of training examples to ﬁne-tune the BERT and pre-train the ALL-CNN-C model respectively.

Original: In text classiﬁcation, we use the text data in a speciﬁc domain to ﬁne-tune BERT, so that we can extract the better text representations from the ﬁne-tuned BERT and improve the performance of the FCN model.
Revised: In text classiﬁcation, we use the text data in a speciﬁc domain to ﬁne-tune BERT, so that we can extract the better text representations from the ﬁne-tuned BERT and improve the performance of the FCN model.

Original: In image classiﬁcation, we ﬁrst pre-train the ALL-CNN-C model using image data, and then the pre-trained model can be helpful to improve downstream tasks for subsequent experiments.
Revised: In image classiﬁcation, we ﬁrst pre-train the ALL-CNN-C model using image data, and then the pre-trained model can be helpful to improve downstream tasks for subsequent experiments.

Original: In Table 2, we list the number of these examples.
Revised: In Table 2, we list the number of these examples.

Original: On SST-2 and SST-5 data sets, we take out 500 training examples of each class to ﬁne-tune the BERT model.
Revised: On SST-2 and SST-5 data sets, we take out 500 training examples of each class to ﬁne-tune the BERT model.

Original: For the experiments on CIFAR10, we use 4000 training examples per class to pre-train the ALL-CNN-C model.
Revised: For the experiments on CIFAR10, we use 4000 training examples per class to pre-train the ALL-CNN-C model.

Original: In the experiments on CIFAR100, we do not pre-train the model, because it can perform well on this binary classiﬁcation task without pre-training.
Revised: In the experiments on CIFAR100, we do not pre-train the model, because it can perform well on this binary classiﬁcation task without pre-training.

Original: Noting that the training examples used to improve the models will not be used in subsequent experiments.
Revised: Noting that the training examples used to improve the models will not be used in subsequent experiments.

Original: Comparison Methods.
Revised: Comparison Methods.

Original: We compare our method with ﬁve approaches: (1) Baseline, a method without any processing.
Revised: We compare our method with ﬁve approaches: (1) Baseline, a method without any processing.

Original: In other words, the classiﬁcation model is directly trained on an imbalanced training set.
Revised: In other words, the classiﬁcation model is directly trained on an imbalanced training set.

Original: (2) Proportion, a commonly used method that weights examples by inverse class frequency.
Revised: (2) Proportion, a commonly used method that weights examples by inverse class frequency.

Original: (3) Hu et al.
Revised: (3) Hu et al.

Original: ’s, is the state-of-the-art approach (Hu et al., 2019) for data weighting, which is described in Section 2 and implemented using the code 1 provided by the authors.
Revised: ’s, is the SOTA approach (Hu et al., 2019) for data weighting, which is described in Section 2 and implemented using the code 1 provided by the authors.

Original: In addition, since we set a small validation set in our experiments, the methods that need to be learned on the validation set are easy to over-ﬁt.
Revised: In addition, since we set a small validation set in our experiments, the methods that need to be learned on the validation set are easy to over-ﬁt.

Original: Therefore, in the following methods, we add regularization for the model parameters in Eq.2.
Revised: Therefore, in the following methods, we add regularization for the model parameters in Eq.2.

Original: (4) Hu et al.
Revised: (4) Hu et al.

Original: ’s+R, a method that adds regularization to the validation learning in the method (Hu et al.).
Revised: ’s+R, a method that adds regularization to the validation learning in the method (Hu et al.).

Original: (5) Two-phase (Wahab et al., 2017), a learning method divided into two phases.
Revised: (5) Two-phase (Wahab et al., 2017), a learning method divided into two phases.

Original: It ﬁrst trains the model to learn a good classiﬁcation representation on an imbalanced training set and then adjusts the imbalance bias of the model by learning on a balanced validation set.
Revised: It ﬁrst trains the model to learn a good classiﬁcation representation on an imbalanced training set and then adjusts the imbalance bias of the model by learning on a balanced validation set.

Original: When the model is trained on the validation set, we also add regularization.
Revised: When the model is trained on the validation set, we also add regularization.

Original: Training and Evaluation.
Revised: Training and Evaluation.

Original: In our experiments, we ﬁrst ﬁne-tune the BERT model and pre-train the ALL-CNN-C model.
Revised: In our experiments, we ﬁrst ﬁne-tune the BERT model and pre-train the ALL-CNN-C model.

Original: In the following training, the text data is ﬁrst converted into vector representations by BERT and then used to train the FCN model, and when training on CIFAR10, the
Revised: In the following training, the text data is ﬁrst converted into vector representations by BERT and then used to train the FCN model, and when training on CIFAR10, the

Original: ALL-CNN-C model is initialized by the pre-trained model.
Revised: ALL-CNN-C model is initialized by the pre-trained model.

Original: Next, we apply different methods to train the models.
Revised: Next, we apply different methods to train the models.

Original: We divide this training process into 2 stages, and we take an imbalanced training set and a small balanced validation set from the remaining training examples (not including the examples used for model preparation).
Revised: We divide this training process into 2 stages, and we take an imbalanced training set and a small balanced validation set from the remaining training examples (not including the examples used for model preparation).

Original: In Stage 1, we only use the training set to train the models, and the trained models can be regarded as the model initialization for subsequent training.
Revised: In Stage 1, we only use the training set to train the models, and the trained models can be regarded as the model initialization for subsequent training.

Original: For the method (Hu et al.), the trained model has basic classiﬁcation capabilities, so that it can use stable gradient information to optimize the weights during weighting the examples (Ren et al., 2018).
Revised: For the method (Hu et al.), the trained model has basic classiﬁcation capabilities, so that it can use stable gradient information to optimize the weights during weighting the examples (Ren et al., 2018).

Original: For the two-phase method, Stage 1 corresponds to its ﬁrst learning phase.
Revised: For the two-phase method, Stage 1 corresponds to its ﬁrst learning phase.

Original: In Stage 2, we train the models according to their respective methods.
Revised: In Stage 2, we train the models according to their respective methods.

Original: Our method and the method (Hu et al.) will learn the model and example weight using the training set and validation set together.
Revised: Our method and the method (Hu et al.) will learn the model and example weight using the training set and validation set together.

Original: For the two-phase method, we only train the model on the balanced validation set, corresponding to its second phase.
Revised: For the two-phase method, we only train the model on the balanced validation set, corresponding to its second phase.

Original: For Baseline and Proportion, the models still learn on the training set.
Revised: For Baseline and Proportion, the models still learn on the training set.

Original:  The settings of the training process on the four data sets are listed in Table 3.
Revised: [Table] [Table] The settings of the training process on the four data sets are listed in Table 3.

Original: Each cell in the table indicates the settings in the current stage, including the optimizer used, learning rate, number of epochs, and batch size, where the value in brackets is the learning rate.
Revised: Each cell in the table indicates the settings in the current stage, including the optimizer used, learning rate, number of epochs [Table] and batch size, where the value in brackets is the learning rate.

Original: In text classiﬁcation, we use
Revised: In text classiﬁcation, we use

Original: Adam optimization.
Revised: Adam optimization.

Original: In image classiﬁcation, we ﬁrst follow the implementation of Springenberg et al.
Revised: In image classiﬁcation, we ﬁrst follow the implementation of Springenberg et al.

Original: to use SGD optimization, and then we use Adam to optimize in subsequent training.
Revised: to use SGD optimization, and then we use Adam to optimize in subsequent training.

Original: Finally, we indicate the evaluation criteria and hyperparameters tuning.
Revised: Finally, we indicate the evaluation criteria and hyperparameters tuning.

Original: We use the accuracy on the full test set of each data set to evaluate the performance of models.
Revised: We use the accuracy on the full test set of each data set to evaluate the performance of models.

Original: During the training process, the ﬁnal result may be over-ﬁtting, so we record the best step corresponding to the highest accuracy on the validation set.
Revised: During the training process, the ﬁnal result may be over-ﬁtting, so we record the best step corresponding to the highest accuracy on the validation set.

Original: In addition, we also tune a series of hyperparameters for different methods and report the best in the test set.
Revised: In addition, we also tune a series of hyperparameters for different methods and report the best in the test set.

Original: For the method (Hu et al.), we follow (Hu et al., 2019) and set the decay of weight to avoid exploding value.
Revised: For the method (Hu et al.), we follow (Hu et al., 2019) and set the decay of weight to avoid exploding value.

Original: The decay value is selected from { 1, 5, 10 } .
Revised: The decay value is selected from { 1, 5, 10 } .

Original: For
Revised: For

Original: Hu+regularization, we set the learning rate for weight update, which is taken from { 1, 1e-1, 1e-2, 1e-3 } .
Revised: Hu+regularization, we set the learning rate for weight update, which is taken from { 1, 1e-1, 1e-2, 1e-3 } .

Original: For our method, we set the learning rate and epochs for updating the weights during learning with constraint, and they are taken from { 1e-2, 1e-3, 1e-4, 1e-5 } and { 1, 5, 10, 15, 30 } respectively.
Revised: For our method, we set the learning rate and epochs for updating the weights during learning with constraint, and they are taken from { 1e-2, 1e-3, 1e-4, 1e-5 } and { 1, 5, 10, 15, 30 } respectively.

Original: We adopt general regularization, namely L p -norm (Bohra & Unser, 2020), for the methods that need to be trained on the validation set.
Revised: We adopt general regularization, namely L p -norm (Bohra & Unser, 2020), for the methods that need to be trained on the validation set.

Original: The value of p is selected from { 2, 4, 6, 8 } .
Revised: The value of p is selected from { 2, 4, 6, 8 } .

Original: The log value of regularization coefﬁcient is selected from { -4, ..., 4 } for text data sets and { -4, ..., 9 } for image data sets.
Revised: The log value of regularization coefﬁcient is selected from { -4, ..., 4 } for text data sets and { -4, ..., 9 } for image data sets.

Original: All experiments were implemented with Python 3.8 and PyTorch 1.8 and were evaluated on a Linux server with RTX 3080 GPU and 128GB RAM.
Revised: All experiments were implemented with Python 3.8 and PyTorch 1.8 and were evaluated on a Linux server with RTX 3080 GPU and 128GB RAM.

Original: All results are averaged over 5 runs ± one standard deviation.
Revised: All results are averaged over 5 runs ± one standard deviation.

Original: 4. R ESULTS ON D IFFERENT D ATA S ETS
Revised: 4. R ESULTS ON D IFFERENT D ATA S ETS

Original: We compare the performance of different methods on the four data sets.
Revised: We compare the performance of different methods on the four data sets.

Original: The four data sets involve text and image domains, as well as binary classiﬁcation and multi-class classiﬁcation scenarios.
Revised: The four data sets involve text and image domains, as well as binary classiﬁcation and multi-class classiﬁcation scenarios.

Original: They can more comprehensively reﬂect the performance of our method.
Revised: They can more comprehensively reﬂect the performance of our method.

Original: In this experiment, we set an imbalance ratio of 1:10, which is the ratio of the example size of the minority class to the majority class.
Revised: In this experiment, we set an imbalance ratio of 1:10, which is the ratio of the example size of the minority class to the majority class.

Original: In all data sets, we set class 0 as the minority class, and the rest as the majority class.
Revised: In all data sets, we set class 0 as the minority class, and the rest as the majority class.

Original: On the four data sets, the size of training examples is different.
Revised: On the four data sets, the size of training examples is different.

Original: We set the number of training examples for each majority class of the data set SST-2, SST-5, CIFAR10, CIFAR100 to 1000, 500, 500,respectively.
Revised: We set the number of training examples for each majority class of the data set SST-2, SST-5, CIFAR10, CIFAR100 to 1000, 500, 500,respectively.

Original: In addition, for all data sets, the number of examples in the validation set is 10 for each class.
Revised: In addition, for all data sets, the number of examples in the validation set is 10 for each class.

Original: The training set and validation set are randomly selected from the remaining training examples in each data set. 
Revised: The training set and validation set are randomly selected from the remaining training examples in each data set. [Table] [Table]

Original: Results
Revised: Results

Original: The results on the four data sets are shown in Table 4.
Revised: The results on the four data sets are shown in Table 4.

Original: We can see that our method has the best performance in these 4 data sets.
Revised: We can see that our method has the best performance in these 4 data sets.

Original: Especially on the SST-5 data set, our method exceeds the second-best method by more than 2 accuracy points.
Revised: Especially on the SST-5 data set, our method exceeds the second-best method by more than 2 accuracy points.

Original: It demonstrates that our method can perform well in multiple domains and different classiﬁcation scenarios.
Revised: It demonstrates that our method can perform well in multiple domains and different classiﬁcation scenarios.

Original: Hu et al.
Revised: Hu et al.

Original: ’+R and Two-phase are competitive methods.
Revised: ’+R and Two-phase are competitive methods.

Original: On the SST-2 and CIFAR100, Hu et al.
Revised: On the SST-2 and CIFAR100, Hu et al.

Original: ’+R is the second-best, and on the
Revised: ’+R is the second-best, and on the

Original: SST-5 and CIFAR10, Two-phase also reaches the second-best.
Revised: SST-5 and CIFAR10, Two-phase also reaches the second-best.

Original: It shows that using a balanced data set to simply adjust a biased model can also achieve good results.
Revised: It shows that using a balanced data set to simply adjust a biased model can also achieve good results.

Original: In addition, Hu et al.
Revised: In addition, Hu et al.

Original: ’+R performs better than Hu et al.
Revised: ’+R performs better than Hu et al.

Original: ’s.
Revised: ’s.

Original: on all data sets, and on the CIFAR100, it surpasses the latter by more than 1 accuracy point.
Revised: on all data sets, and on the CIFAR100, it surpasses the latter by more than 1 accuracy point.

Original: It indicates that adding regularization to the validation learning can effectively[Table] [Table] improve the method (Hu et al.).
Revised: It indicates that adding regularization to the validation learning can effectively improve the method (Hu et al.).

Original: However, on the SST-5, the method (Hu et al.) performs worse than the baseline, which may be due to the ineffectiveness of the approximation on SST-5.
Revised: However, on the SST-5, the method (Hu et al.) performs worse than the baseline, which may be due to the ineffectiveness of the approximation on SST-5.

Original: The accuracy of the proportion method is lower than that of our method by more than 2 accuracy points on the
Revised: The accuracy of the proportion method is lower than that of our method by more than 2 accuracy points on the

Original: SST-2, SST-5, and CIFAR100.
Revised: SST-2, SST-5, and CIFAR100.

Original: It shows that the method of learning weight has more advantages than weighting empirically.
Revised: It shows that the method of learning weight has more advantages than weighting empirically.

Original: The baseline method performs the worst on three data sets due to the lack of measures to solve the imbalance.
Revised: The baseline method performs the worst on three data sets due to the lack of measures to solve the imbalance.

Original: 4. R ESULTS OF D IFFERENT I MBALANCE R ATIOS
Revised: 4. R ESULTS OF D IFFERENT I MBALANCE R ATIOS

Original: We study the performance of our method with different imbalance ratios.
Revised: We study the performance of our method with different imbalance ratios.

Original: In this experiment, we use the SST-2 and CIFAR100 data sets, and we vary the imbalance ratio from { 1:10, 1:50, 1:100 } .
Revised: In this experiment, we use the SST-2 and CIFAR100 data sets, and we vary the imbalance ratio from { 1:10, 1:50, 1:100 } .

Original: The example size of majority classes in the training set and the validation set are consistent with the setting of Section 4.2.
Revised: The example size of majority classes in the training set and the validation set are consistent with the setting of Section 4.2.

Original: In addition, the training set and validation set are also randomly constructed.
Revised: In addition, the training set and validation set are also randomly constructed.

Original: Results Table 5 and Table 6 respectively shows the results of different imbalance ratios on SSTand CIFAR100 data set.
Revised: Results Table 5 and Table 6 respectively shows the results of different imbalance ratios on SSTand CIFAR100 data set.

Original: The results are listed in the order of imbalance ratios of 1:10, 1:50, 1:100.
Revised: The results are listed in the order of imbalance ratios of 1:10, 1:50, 1:100.

Original: There are three main observations.
Revised: There are three main observations.

Original: First, our method has achieved the highest accuracy rates in all imbalance ratio settings.
Revised: First, our method has achieved the highest accuracy rates in all imbalance ratio settings.

Original: It further demonstrates that our method can have excellent performance in different situations, such as slight imbalance, extreme imbalance, etc.
Revised: It further demonstrates that our method can have excellent performance in different situations, such as slight imbalance, extreme imbalance, etc.

Original: Second, as the training data becomes more imbalanced, the performance of our method is more dominant than other methods.
Revised: Second, as the training data becomes more imbalanced, the performance of our method is more dominant than other methods.

Original: On the SST-2, the accuracy of our method exceeds the second-best method by about 0.3 at 100: and more than 5 accuracy points at 10:1000.
Revised: On the SST-2, the accuracy of our method exceeds the second-best method by about 0.3 at 100: and more than 5 accuracy points at 10:1000.

Original: Similarly, on the CIFAR100, the accuracy of our method improves the second-best method over 0.9 at 100:1000 and more than 6 accuracy points at 10:1000.
Revised: Similarly, on the CIFAR100, the accuracy of our method improves the second-best method over 0.9 at 100:1000 and more than 6 accuracy points at 10:1000.

Original: It shows that our method is more advantageous in extreme imbalance.
Revised: It shows that our method is more advantageous in extreme imbalance.

Original: Third, when the imbalance ratios are 1:50 and 1:100, the accuracy rates of the proportion method are almost lower than other imbalance classiﬁcation methods.
Revised: Third, when the imbalance ratios are 1:50 and 1:100, the accuracy rates of the proportion method are almost lower than other imbalance classiﬁcation methods.

Original: On the CIFAR100, the proportion method even performs worse than the baseline.
Revised: On the CIFAR100, the proportion method even performs worse than the baseline.

Original: It indicates that as the data imbalance becomes serious, the[Table] proportion method may not be effective.
Revised: It indicates that as the data imbalance becomes serious, the proportion method may not be effective.

Original: On the contrary, the advantage of the methods of learning weights is more obvious.
Revised: On the contrary, the advantage of the methods of learning weights is more obvious.

Original:  R ELATED W ORK
Revised:  R ELATED W ORK

Original: There have been very rich studies on weighting examples for imbalance classiﬁcation, and these studies can be grouped into two categories, namely empirical weighting and automatic weighting.
Revised: There have been very rich studies on weighting examples for imbalance classiﬁcation, and these studies can be grouped into two categories, namely empirical weighting and automatic weighting.

Original: Empirical Weighting.
Revised: Empirical Weighting.

Original: The empirical weighting methods assign the manual weight values to the examples.
Revised: The empirical weighting methods assign the manual weight values to the examples.

Original: Generally, the minority class example will be assigned a larger weight value than that of the majority class, so as to relieve the bias of the model trained on the imbalanced data set.
Revised: Generally, the minority class example will be assigned a larger weight value than that of the majority class, so as to relieve the bias of the model trained on the imbalanced data set.

Original: The methods of weighting by class are ﬁrst proposed (King & Zeng, 2001).
Revised: The methods of weighting by class are ﬁrst proposed (King & Zeng, 2001).

Original: In these methods, the examples of each class are manually set to the same value, such as inverse class frequency (Wang et al., 2017;
Revised: In these methods, the examples of each class are manually set to the same value, such as inverse class frequency (Wang et al., 2017;

Original: Huang et al., 2016) or inverse square root of class frequency (Mikolov et al., 2013; Mahajan et al., 2018).
Revised: Huang et al., 2016) or inverse square root of class frequency (Mikolov et al., 2013; Mahajan et al., 2018).

Original: Cui et al.
Revised: Cui et al.

Original: (2019) proposed to calculate the effective number of examples as class frequency and then also use its inverse to weight examples and achieved signiﬁcant improvements on longtailed training data.
Revised: (2019) proposed to calculate the effective number of examples as class frequency and then also use its inverse to weight examples and achieved signiﬁcant improvements on longtailed training data.

Original: In addition, many methods of weighting by example have also been proposed.
Revised: In addition, many methods of weighting by example have also been proposed.

Original: Hard example mining (Shrivastava et al., 2016) thought focusing on the hard examples can improve the model on the imbalanced data.
Revised: Hard example mining (Shrivastava et al., 2016) thought focusing on the hard examples can improve the model on the imbalanced data.

Original: Dong et al.
Revised: Dong et al.

Original: ; Malisiewicz et al.
Revised: ; Malisiewicz et al.

Original: (2011) proposed to utilize the example loss to ﬁnd hard examples and assign them higher weights.
Revised: (2011) proposed to utilize the example loss to ﬁnd hard examples and assign them higher weights.

Original: Lin et al.
Revised: Lin et al.

Original: (2017) proposed to use the predicted probability to calculate higher weights for the hard examples and dynamically adjust the weight values during training.
Revised: (2017) proposed to use the predicted probability to calculate higher weights for the hard examples and dynamically adjust the weight values during training.

Original: Empirical weighting is convenient to implement and can achieve excellent performance, though it cannot adapt to different data sets and may cause poor performance.
Revised: Empirical weighting is convenient to implement and can achieve excellent performance, though it cannot adapt to different data sets and may cause poor performance.

Original: In addition, manually setting weights will also increase the engineering burden.
Revised: In addition, manually setting weights will also increase the engineering burden.

Original: Automatic Weighting.
Revised: Automatic Weighting.

Original: The automatic weighting methods assign adaptive weights to the examples through learning mechanisms.
Revised: The automatic weighting methods assign adaptive weights to the examples through learning mechanisms.

Original: Curriculum learning can provide an example weighting strategy for neural network models to learn on corrupted labels (Jiang et al., 2018; Wei et al., 2021), but the method focuses on examples that are easy to learn (Zhang et al., 2020).
Revised: Curriculum learning can provide an example weighting strategy for neural network models to learn on corrupted labels (Jiang et al., 2018; Wei et al., 2021), but the method focuses on examples that are easy to learn (Zhang et al., 2020).

Original: On the contrary, imbalance learning prefers hard examples, so it is different from the methods of data weighting in imbalance classiﬁcation.
Revised: On the contrary, imbalance learning prefers hard examples, so it is different from the methods of data weighting in imbalance classiﬁcation.

Original: Ren et al.
Revised: Ren et al.

Original: (2018) proposed to learn the example weights by a meta-learning paradigm (Zhang et al., 2021).
Revised: (2018) proposed to learn the example weights by a meta-learning paradigm (Zhang et al., 2021).

Original: This algorithm treats the example weights as a meta-learner and guides the learner to learn on the imbalanced training set.
Revised: This algorithm treats the example weights as a meta-learner and guides the learner to learn on the imbalanced training set.

Original: The loss on the balanced validation set is used as the meta-objective to optimize the example weights (Bai et al., 2021).
Revised: The loss on the balanced validation set is used as the meta-objective to optimize the example weights (Bai et al., 2021).

Original: In each iteration of updating the weights, this algorithm uses a gradient descent step to approximate the relationship between the weights and the learner.
Revised: In each iteration of updating the weights, this algorithm uses a gradient descent step to approximate the relationship between the weights and the learner.

Original: Hu et al.
Revised: Hu et al.

Original: (2019) improved the algorithm by iteratively optimizing weights instead of re-estimation at each iteration.
Revised: (2019) improved the algorithm by iteratively optimizing weights instead of re-estimation at each iteration.

Original: Our work is based on the work of Ren and Hu et al.
Revised: Our work is based on the work of Ren and Hu et al.

Original: and make further research.
Revised: and make further research.

Original: There is a key difference between our work and theirs.
Revised: There is a key difference between our work and theirs.

Original: We use the model optimization objective to derive the precise relationship between the model and weights, instead of the local approximation strategy they used.
Revised: We use the model optimization objective to derive the precise relationship between the model and weights, instead of the local approximation strategy they used.

Original: Therefore, our algorithm can accurately optimize the example weights and get a better model for imbalance classiﬁcation.
Revised: Therefore, our algorithm can accurately optimize the example weights and get a better model for imbalance classiﬁcation.

Original: The massive experimental results show that our algorithm makes signiﬁcant improvements.
Revised: The massive experimental results show that our algorithm makes signiﬁcant improvements.

Original:  C ONCLUSION
Revised:  C ONCLUSION

Original: In this paper, based on the work of Ren and Hu et al.
Revised: In this paper, based on the work of Ren and Hu et al.

Original: , we further propose an improved algorithm to learn the example weights for imbalance classiﬁcation.
Revised: , we further propose an improved algorithm to learn the example weights for imbalance classiﬁcation.

Original: In this algorithm, we propose a learning mechanism that can accurately update the weights and the classiﬁcation model under a constraint and improves the validation performance of the model.
Revised: In this algorithm, we propose a learning mechanism that can accurately update the weights and the classiﬁcation model under a constraint and improves the validation performance of the model.

Original: This is a key improvement compared to the method proposed by Ren et al.
Revised: This is a key improvement compared to the method proposed by Ren et al.

Original: that uses the local approximation to optimize the weights.
Revised: that uses the local approximation to optimize the weights.

Original: In addition, the algorithm we proposed is a combination of our learning mechanism and the method proposed by Hu et al., which can promote each other and make the model perform better.
Revised: In addition, the algorithm we proposed is a combination of our learning mechanism and the method proposed by Hu et al., which can promote each other and make the model perform better.

Original: Finally, the experimental evaluation shows that our algorithm can achieve signiﬁcant improvement compared with the state-of-the-art method in data weighting and other imbalance methods.
Revised: Finally, the experimental evaluation shows that our algorithm can achieve signiﬁcant improvement compared with the SOTA method in data weighting and other imbalance methods.

Original: In our future work, we plan to extend our algorithm and explore the performance of our algorithm in data augmentation. 
Revised: In our future work, we plan to extend our algorithm and explore the performance of our algorithm in data augmentation. Acknowledgements.

Revised: This research was partially sponsored by the following funds: National

Revised: Key R&D Program of China (2018YFB1402800), Key Research Project of Zhejiang Province (2022C01145), Fundamental Research Funds for the Provincial Universities of Zhejiang (RFA2020007) and Zhejiang Lab (2020AA3AB05).

Original: A A PPENDIX A. E XPERIMENTAL R ESULTS WITH D IFFERENT M ETRICS
Revised: A A PPENDIX A. E XPERIMENTAL R ESULTS WITH D IFFERENT M ETRICS

Original: In this section we evaluate the performance of our methods with different metrics on a large-scale data set.
Revised: In this section we evaluate the performance of our methods with different metrics on a large-scale data set.

Original: In addition to the accuracy we also adopt the Marco-F1 score and G-means that are often used in imbalanced classiﬁcation.
Revised: In addition to the accuracy we also adopt the Marco-F1 score and G-means that are often used in imbalanced classiﬁcation.

Original: In this experiment we use an additional large-scale unbalanced data set that is the operational data for Air Pressure System (APS) Failure at Scania trucks.
Revised: In this experiment we use an additional large-scale unbalanced data set that is the operational data for Air Pressure System (APS) Failure at Scania trucks.

Original: The settings and results of this experiment are as follows.
Revised: The settings and results of this experiment are as follows.

Original: [Table] [Table]
Revised: [Table] [Table]

Original: [Table]
Revised: [Table]

Original: Dataset and Models.
Revised: Dataset and Models.

Original: APS Failure dataset is from UCI Machine Learning Repository (Dua & Graff, 2017).
Revised: APS Failure dataset is from UCI Machine Learning Repository (Dua & Graff, 2017).

Original: This dataset contains 76000 examples.
Revised: This dataset contains 76000 examples.

Original: We randomly construct the train, validation and test data sets from the original data set.
Revised: We randomly construct the train, validation and test data sets from the original data set.

Original: These sub-data sets are described in Table 8.
Revised: These sub-data sets are described in Table 8.

Original: The train set consists of 10000 negative examples and 10 positive examples, which is extremely imbalanced
Revised: The train set consists of 10000 negative examples and 10 positive examples, which is extremely imbalanced

Original: [Table]
Revised: [Table]

Original: and its imbalance rate reaches 1:1000.
Revised: and its imbalance rate reaches 1:1000.

Original: The validation and test sets are balanced data sets
Revised: The validation and test sets are balanced data sets

Original: [Table]
Revised: [Table]

Original: and their example sizes for each class are 5 and 1000 respectively.
Revised: and their example sizes for each class are 5 and 1000 respectively.

Original: In addition, APS Failure dataset dataset has 171 features
Revised: In addition, APS Failure dataset dataset has 171 features

Original: [Table]
Revised: [Table]

Original: and we replace the missing feature values with the average of the examples in the same class.
Revised: and we replace the missing feature values with the average of the examples in the same class.

Original: Finally, we scale the all feature values to [0 , 1] .
Revised: Finally, we scale the all feature values to [0 , 1] .

Original: The model for APS Failure dataset is shown in Table 7 and is a simple 3-layer FCN.
Revised: The model for APS Failure dataset is shown in Table 7 and is a simple 3-layer FCN.

Original: Other Settings.
Revised: Other Settings.

Original: During training, we use Adam optimization with an initial learning rate of 1eand set the batch size to 128.
Revised: During training, we use Adam optimization with an initial learning rate of 1eand set the batch size to 128.

Original: Other hyperparameter settings are the same as the text classiﬁcation in
Revised: Other hyperparameter settings are the same as the text classiﬁcation in

Original: Section 4.1.
Revised: Section 4.1.

Original: Results.
Revised: Results.

Original: The results of different metrics on APS Failure dataset are shown in Table 9.
Revised: The results of different metrics on APS Failure dataset are shown in Table 9.

Original: There are three main observations.
Revised: There are three main observations.

Original: First, our method achieves the best score in all metrics.
Revised: First, our method achieves the best score in all metrics.

Original: It indicates that our method has comprehensive advantages compared with other methods.
Revised: It indicates that our method has comprehensive advantages compared with other methods.

Original: Second, the score rankings of the six methods are almost consistent among these metrics.
Revised: Second, the score rankings of the six methods are almost consistent among these metrics.

Original: It shows that the evaluation of these metrics on a balanced test set is similar.
Revised: It shows that the evaluation of these metrics on a balanced test set is similar.

Original: Third, our method performs well on a large-scale data set.
Revised: Third, our method performs well on a large-scale data set.

Original: It demonstrates that our method is also effective on large-scale data.
Revised: It demonstrates that our method is also effective on large-scale data.

Original: A. C ONVERGENCE P ROOF OF O UR M ETHOD
Revised: A. C ONVERGENCE P ROOF OF O UR M ETHOD

Original: This section ﬁrstly provides a proof of the convergence of the learning method with a constraint in
Revised: This section ﬁrstly provides a proof of the convergence of the learning method with a constraint in

Original: Section 3.1, and then we prove the convergence of the combination method in Section 3.2.
Revised: Section 3.1, and then we prove the convergence of the combination method in Section 3.2.

Original: Deﬁnition 1.
Revised: Deﬁnition 1.

Original: A function f ( x ) : R d → R is said to be Lipschitz-smooth with constant L if
Revised: A function f ( x ) : R d → R is said to be Lipschitz-smooth with constant L if

Original: [Equation]
Revised: [Equation]

Original: Deﬁnition 2.
Revised: Deﬁnition 2.

Original: A function f ( x ) has σ -bounded gradients
Revised: A function f ( x ) has σ -bounded gradients

Original: if
Revised: if

Original: [Equation]
Revised: [Equation]

Original: Theorem 1.
Revised: Theorem 1.

Original: Suppose the validation loss function L val is Lipschitz-smooth with constant L, and the training loss function f
Revised: Suppose the validation loss function L val is Lipschitz-smooth with constant L, and the training loss function f

Original: i corresponding to the example x i has σ -bounded gradients and the Hessian matrix H , namely, the second derivative of L train with respect to θ , is bounded by ρ .
Revised: i corresponding to the example x i has σ -bounded gradients and the Hessian matrix H , namely, the second derivative of L train with respect to θ , is bounded by ρ .

Original: Let the learning rate η (cid:48)
Revised: Let the learning rate η (cid:48)

Original: w t satisﬁes η (cid:48) w t ≤ [Equation] [Equation]
Revised: w t satisﬁes η (cid:48) w t ≤ 2 LN 2 σ

Original: [Equation]
Revised: [Equation]

Original: Then, after each iteration of the model parameter θ , the validation loss always decreases.
Revised: Then, after each iteration of the model parameter θ , the validation loss always decreases.

Original: More speciﬁcally,
Revised: More speciﬁcally,

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: The validation loss function L val is Lipschitz-smooth, so we have
Revised: The validation loss function L val is Lipschitz-smooth, so we have

Original: [Equation]
Revised: [Equation]

Original: Let v = ( ∇ θ L val )
Revised: Let v = ( ∇ θ L val )

Original: T ∆ θ + L 2 (cid:107) ∆ θ (cid:107) .
Revised: T ∆ θ + L 2 (cid:107) ∆ θ (cid:107) .

Original: We can see that only v ≤ 0 , there is L val ( θ t +1 ) ≤ L val ( θ t ) .
Revised: We can see that only v ≤ 0 , there is L val ( θ t +1 ) ≤ L val ( θ t ) .

Original: Then, substituting the θ update formula: ∆ θ = ∇ w θ ( w t +1 − w t ) and the w update formula: w t +1 − w t
Revised: Then, substituting the θ update formula: ∆ θ = ∇ w θ ( w t +1 − w t ) and the w update formula: w t +1 − w t

Original: =
Revised: =

Original: η (cid:48)
Revised: η (cid:48)

Original: w t ( ∇ w θ ) T ∇ θ L val from Section 3.1 into v , we have
Revised: w t ( ∇ w θ ) T ∇ θ L val from Section 3.1 into v , we have

Original: [Equation]
Revised: [Equation]

Original: where I is the identity matrix.
Revised: where I is the identity matrix.

Original: Let S = ∇ w θ ( ∇ w θ )
Revised: Let S = ∇ w θ ( ∇ [Equation] ∇

Original: [Equation]
Revised: [Equation]

Revised: θ

Revised: [Equation]

Revised: ∇

Original: ∇ w θ ( ∇ w θ ) T − η (cid:48)
Revised: [Equation] θ ) [Equation] − η (cid:48)

Original: w t I (cid:105) , so v = ( ∇ θ L val ) T S ∇ θ L val .
Revised: w t I (cid:105) , so v = ( ∇ θ L val ) T S ∇ θ L val .

Original: Next, we prove that S is a semi-negative deﬁnite matrix such that v ≤ 0 .
Revised: Next, we prove that S is a semi-negative deﬁnite matrix such that v ≤ 0 .

Original: We observe that in S , the term ∇ w θ ( ∇ w θ ) T is a symmetric and positive semi-deﬁnite matrix.
Revised: We observe that in S , the term ∇ w θ ( ∇ w θ ) T is a symmetric and positive semi-deﬁnite matrix.

Original: We use A to denote this term and deﬁne its eigendecomposition as A =
Revised: We use A to denote this term and deﬁne its eigendecomposition as A =

Original: Pdiag ( λ ) P − 1 where λ is a vector composed of eigenvalues
Revised: Pdiag ( λ ) P − 1 where λ is a vector composed of eigenvalues

Original: and λ i ≥ 

Revised: and λ i ≥

Original: for all i .
Revised: for all i .

Original: Substituting this eigendecomposition into S , we have
Revised: Substituting this eigendecomposition into S , we have

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: where ∗ represents the hadamard product.
Revised: where ∗ represents the hadamard product.

Original: Therefore, in order to make S a semi-negative deﬁnite matrix, η (cid:48)
Revised: Therefore, in order to make S a semi-negative deﬁnite matrix, η (cid:48)

Original: w t must satisﬁes Lη (cid:48) wt2λ
Revised: w t must satisﬁes Lη [Equation] wt

Original: [Equation]
Revised: [Equation]

Original: − η
Revised: λ

Original: [Equation]
Revised: [Equation]

Original: w t λ i ≤ 0 for all i , namely, 0 ≤ η (cid:48)
Revised: ≤ 0 for all i , namely, 0 ≤ η (cid:48)

Original: w t ≤ 2 Lλ i .
Revised: w t ≤ 2 Lλ i .

Original: Let λ max = max i ( λ i ) , so ﬁnally η (cid:48)
Revised: Let λ max = max i ( λ i ) , so ﬁnally η (cid:48)

Original: w t must satisﬁes
Revised: w t must satisﬁes

Original: [Equation]
Revised: [Equation]

Original: Further, we estimate the boundary of the scalar value λ max .
Revised: Further, we estimate the boundary of the scalar value λ max .

Original: In Section 2, we deﬁne a matrix
Revised: In Section 2, we deﬁne a matrix

Original: F = ( ∇ f 1 , ..., ∇ f N ) , where f i is the training loss function and N is the number of the training examples.
Revised: F = ( ∇ f 1 , ..., ∇ f N ) , where f i is the training loss function and N is the number of the training examples.

Original: Since f i has σ -bounded gradients, we can obtain (cid:107) F (cid:107)≤ Nσ .
Revised: Since f i has σ -bounded gradients, we can obtain (cid:107) F (cid:107)≤ Nσ .

Original: Substituting ∇ w θ in Eq.
Revised: Substituting ∇ w θ in Eq.

Original: 7 into A , we have
Revised: 7 into A , we have

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Original: Since λ max is the eigenvalue of A , we can obtain
Revised: Since λ max is the eigenvalue of A , we can obtain

Original: [Equation]
Revised: [Equation]

Original: Therefore, combining Eq. 17 and Eq.
Revised: Therefore, combining Eq. 17 and Eq.

Original: 20, the satisfying range of η (cid:48)
Revised: 20, the satisfying range of η (cid:48)

Original: w t is
Revised: w t is

Revised: [Equation]

Original: [Equation]
Revised: [Equation]

Original: This ﬁnishes our proof for Theorem 1.
Revised: This ﬁnishes our proof for Theorem 1.

Original: Theorem 2.
Revised: Theorem 2.

Original: Suppose the validation loss function L val , the training loss function f
Revised: Suppose the validation loss function L val , the training loss function f

Original: i and the learning rate η (cid:48)
Revised: i and the learning rate η (cid:48)

Original: w t satisﬁes Theorem 1 conditions.
Revised: w t satisﬁes Theorem 1 conditions.

Original: Same as Algorithm 1, t is denoted as the time step where the algorithm successively uses Hu et al.
Revised: Same as Algorithm 1, t is denoted as the time step where the algorithm successively uses Hu et al.

Original: and our methods to update θ , and let t (cid:48) represent the time step inside time-step t and the algorithm only apply our method to update θ .
Revised: and our methods to update θ , and let t (cid:48) represent the time step inside time-step t and the algorithm only apply our method to update θ .

Original: The range of t (cid:48) is [0 , ..., T 2 − 1] .
Revised: The range of t (cid:48) is [0 , ..., T 2 − 1] .

Original: Then the validation loss always decreases after the t -th iteration, namely,
Revised: Then the validation loss always decreases after the t -th iteration, namely,

Original: [Equation]
Revised: [Equation]

Original: Proof.
Revised: Proof.

Original: The θ t (cid:48)
Revised: The θ t (cid:48)

Original: =0 is the updated parameter through the method (Hu et al.).
Revised: =0 is the updated parameter through the method (Hu et al.).

Original: According to the convergence theorem in the paper (Ren et al., 2018; Hu et al., 2019), we can obtain
Revised: According to the convergence theorem in the paper (Ren et al., 2018; Hu et al., 2019), we can obtain

Original: [Equation]
Revised: [Equation]

Original: After that, we use our method to update the parameter T times.
Revised: After that, we use our method to update the parameter T times.

Original: According to the Theorem 1, we have
Revised: According to the Theorem 1, we have

Original: [Equation]
Revised: [Equation]

Original: Here, the algorithm completes the update of the parameter in time-step t , namely, θ t
Revised: Here, the algorithm completes the update of the parameter in time-step t , namely, θ t

Original: [Equation]
Revised: [Equation]

Original: = T 2 − [Equation] = θ 
Revised: = T 2 − 1 = θ t +1 .

Original: [Equation]

Original: Combining Eq.
Revised: Combining Eq.

Original: 23 and Eq.
Revised: 23 and Eq.

Original: 24, we can obtain
Revised: 24, we can obtain

Original: [Equation]
Revised: [Equation]

Original: This ﬁnishes our proof of Theorem 2.
Revised: This ﬁnishes our proof of Theorem 2.

Original: A. C ONVERGENCE R ATE OF O UR M ETHOD
Revised: A. C ONVERGENCE R ATE OF O UR M ETHOD

Original: This section provides a proof of the convergence rate of the learning method with a constraint in
Revised: This section provides a proof of the convergence rate of the learning method with a constraint in

Original: Section 3.1.
Revised: Section 3.1.

Original: Theorem 3.
Revised: Theorem 3.

Original: Suppose the validation loss function L val , the training loss function f
Revised: Suppose the validation loss function L val , the training loss function f

Original: i and the learning rate η (cid:48)
Revised: i and the learning rate η (cid:48)

Original: w t satisﬁes Theorem 1 conditions.
Revised: w t satisﬁes Theorem 1 conditions.

Original: Then the learning method in Section 3.1 achieves (cid:107) ∇ θ t L val (cid:107)≤ (cid:15) in O ( 1 (cid:15) ) steps, namely,
Revised: Then the learning method in Section 3.1 achieves (cid:107) ∇ θ t L val (cid:107)≤ [Equation] in O ( 1 (cid:15) ) steps, namely,

Original: [Equation]
Revised: [Equation]

Original: where C is some constant
Revised: where C is some constant

Original: Proof.
Revised: Proof.

Original: According to Eq.
Revised: According to Eq.

Original: 11 and Eq.
Revised: 11 and Eq.

Original: 14 in Theorem 1, we can obtain
Revised: 14 in Theorem 1, we can obtain

Original: [Equation]
Revised: [Equation]

Original:  where S t is the matrix S at time-step t and S is deﬁned in Theorem 1.
Revised: ) where S t is the matrix S at time-step t and S is deﬁned in Theorem 1.

Original: Then we have
Revised: Then we have

Original: [Equation]
Revised: [Equation]

Original: where L val ( θ ∗ ) is the minimum of function L val ( θ ) .
Revised: where L val ( θ ∗ ) is the minimum of function L val ( θ ) .

Original: Then, we can observe that there exist a timestep 0 ≤ τ ≤ T such that,
Revised: Then, we can observe that there exist a timestep 0 ≤ τ ≤ T such that,

Original: [Equation]
Revised: [Equation]

Original: [Equation]

Original: We have proved that S τ is a semi-negative deﬁnite matrix.
Revised: We have proved that S τ is a semi-negative deﬁnite matrix.

Original: According to Eq.
Revised: According to Eq.

Original: 16, we have
Revised: 16, we have

Original: [Equation]
Revised: [Equation]

Original: where λ (cid:48) is a vector composed of eigenvalues and λ (cid:48)
Revised: where λ (cid:48) is a vector composed of eigenvalues and λ (cid:48)

Original: i ≤ 0 for all i .
Revised: i ≤ 0 for all i .

Original: P is the matrix composed of eigenvectors of A in Theorem 1 and P − 1 =
Revised: P is the matrix composed of eigenvectors of A in Theorem 1 and P − 1 =

Original: P T because A is a symmetric matrix.
Revised: P T because A is a symmetric matrix.

Original: Substituting Eq.
Revised: Substituting Eq.

Original: 30 into Eq.
Revised: 30 into Eq.

Original: 29, we have
Revised: 29, we have

Original: [Equation]
Revised: [Equation]

Original: We can regard Eq.
Revised: We can regard Eq.

Original: 32 as the quadratic form of the diagonal matrix diag ( λ (cid:48) ) ,
Revised: 32 as the quadratic form of the diagonal matrix diag ( λ (cid:48) ) ,

Original: and we scale all the eigenvalues λ (cid:48)
Revised: and we scale all the eigenvalues λ (cid:48)

Original: i to λ (cid:48) max where λ (cid:48) max = max i λ (cid:48)
Revised: i to λ (cid:48) max where λ (cid:48) max = max i λ (cid:48)

Original: i , so that we obtain the inequality in Eq.
Revised: i , so that we obtain the inequality in Eq.

Original: So we have
Revised: So we have

Original: [Equation]
Revised: [Equation]

Original: where
Revised: where

Original: C =
Revised: C =

Original: L val ( θ ∗ ) −L val ( θ 0 ) λ (cid:48) max is a constant independent of T .
Revised: L val ( θ ∗ ) −L val ( θ 0 ) λ (cid:48) max is a constant independent of T .

Original: Therefore, we can obtain min 0 <t<T (cid:107) ∇ θ t L val (cid:107)≤(cid:107) ∇ θ τ L val (cid:107)≤ CT .
Revised: Therefore, we can obtain min 0 <t<T (cid:107) ∇ θ t L val (cid:107)≤(cid:107) ∇ θ τ L val (cid:107)≤ CT .

Original: It means that our method can achieve min 0 <t<T (cid:107) ∇ θ t L val (cid:107)≤ O ( 1 T ) in T steps.
Revised: It means that our method can achieve min 0 <t<T (cid:107) ∇ θ t L val (cid:107)≤ O ( 1 T ) in T steps.

Original: This ﬁnishes our proof of Theorem 3.
Revised: This ﬁnishes our proof of Theorem 3.