{'fraction_non_alphanumeric': 0.03643120315080676, 'fraction_numerical': 0.014229449879303774, 'mean_word_length': 4.532419609910384, 'pattern_counts': {'":': 0, '<': 2, '<?xml version=': 0, '>': 7, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
A New Adaptive Gradient Method with Gradient Decomposition

Adaptive gradient methods, especially Adam-type methods (such as Adam, AMSGrad, and AdaBound), have been proposed to speed up the training process with an element-wise scaling term on learning rates. However, they often generalize poorly compared with stochastic gradient descent (SGD) and its accelerated schemes such as SGD with momentum (SGDM). In this paper, we propose a new adaptive method called DecGD, which simultaneously achieves good generalization like SGDM and obtain rapid convergence like Adam-type methods. In particular, DecGD decomposes the current gradient into the product of two terms including a surrogate gradient and a loss based vector. Our method adjusts the learning rates adaptively according to the current loss based vector instead of the squared gradients used in Adam-type methods. The intuition for adaptive learning rates of DecGD is that a good optimizer, in general cases, needs to decrease the learning rates as the loss decreases, which is similar to the learning rates decay scheduling technique. Therefore, DecGD gets a rapid convergence in the early phases of training and controls the effective learning rates according to the loss based vectors which help lead to a better generalization. Convergence analysis is discussed in both convex and non-convex situations. Finally, empirical results on widely-used tasks and models demonstrate that DecGD shows better generalization performance than SGDM and rapid convergence like Adam-type methods.


Introduction
Consider the following stochastic optimization problem: where S ∼ P is a random variable, f (x; s) is the instantaneous loss parameterized by x on a sample s ∈ S, X ⊆ R d is a closed convex set. This problem is a common learning task in machine learning and deep learning. Many efforts have been spent on proposing stochastic optimization methods to solve this problem. Stochastic gradient descent (SGD) is the dominant first-order method for the above problem Krizhevsky et al. [2012], Graves et al. [2013], Lecun et al. [1998]. SGD is often trained in the form of mini-batch SGD in order to meet the requirements of computing power, and achieve better generalization performance Heskes and Kappen [1993], LeCun et al. [2012]. However, SGD has the following main drawbacks. First, SGD chooses the negative gradients of loss functions as descent directions which would yield a slow convergence near the local minima. Second, SGD scales the gradients uniformly in all directions which may yield poor performance as well as limited training speed. Last but not least, when applied to machine learning and deep learning tasks, SGD is painstakingly hard to tune the learning rates decay scheduling manually. However, one has to decay learning rates as the algorithm proceeds in order to control the variances of stochastic gradients for achieving convergence due to the high-dimensional non-convexity of machine learning and deep learning optimization problems.
To tackle aforementioned issues, considerable efforts have been spent and several remarkable variants have been proposed recently. Accelerated schemes and adaptive methods are two categories of dominant variants. Accelerated schemes, such as Nesterov's accelerated gradient (NAG) Nesterov [1983] and SGD with momentum (SGDM) Polyak [1964], employ momentum to adjust descent directions which can help achieve faster convergence and better generalization performance than other variants. However, they also suffer from the third drawback of SGD so that one need to spend many efforts on tuning and decaying learning rates manually. On the other hand, adaptive methods aim to alleviate this issue which automatically decay the learning rates and scale them nonuniformly. The first prominent algorithm in this line of research is AdaGrad Duchi et al. [2011], which divides element-wisely accumulative squared historical gradients. AdaGrad performs well when gradients are sparse, but its performance degrades in dense or non-convex settings which is attributed to the rapid decay in learning rates. Towards this end, several methods proposed scale gradients down by square roots of exponential moving averages of squared historical gradients (called EMA mechanism) which focus on only the recent gradients. This mechanism is very popular and some famous variants, including AdaDelta Zeiler [2012], RMSprop Tieleman and Hinton [2012] and Adam Kingma and Ba [2015], are based on it. Particularly, Adam is a combination of momentum and EMA mechanism which converges fast in the early training phases and is easier to tuning than SGD, becoming the default algorithms leveraged across various deep learning frameworks.
Despite Adam's popularity, there also have been concerns about their convergence and generalization properties. In particular, EMA based methods may not converge to the optimal solution even in simple convex settings Reddi et al. [2018] which relies on the fact that effective learning rates of EMA based methods can potentially increase over time in a fairly quickly manner. For convergence, it is important to have the effective learning rates decrease over iterations, or at least have controlled increase Zaheer et al. [2018]. Moreover, this problem persists even if the learning rate scheduling ( [2020] to narrow the generalization gap between EMA based methods with SGD. However, one pursuing the best generalization ability of models has to choose SGD as the default optimizer rather than Adam based on the fact that there is not enough evidence to show that those Adam-type methods, which claim to improve the generalization ability of the EMA mechanism, can get close to or even surpass SGD in general tasks. Therefore, a natural idea is whether it is possible to develop a new adaptive method different form EMA based methods, which can overcome aforementioned issues and obtain even better generalization than SGD. However, to the best of our knowledge, there exists few efforts on proposing new adaptive mechanisms whose starting points are different form EMA mechanism.
Contributions In the light of this background, we list the main contributions of our paper.
• We propose a new adaptive method, called DecGD, different from Adam-type methods. DecGD decomposes gradients into the product of two terms including surrogate gradients and loss based vectors. Our method achieves adaptivity in SGD according to loss based vectors with the intuition that a good optimizer, in general cases, needs to decrease the learning rates as the loss decreases, which is similar to the learning rates decay scheduling technique. DecGD overcomes aforementioned drawbacks of SGD and achieve comparable and even better generalization than SGD with momentum. • We theoretically analyze the convergence of DecGD in both convex and non-convex settings.
• We conduct extensive empirical experiments for DecGD and compare with several representative methods. Empirical results show that DecGD is robust to hyperparameters and learning rates. Moreover, our method achieves fast convergence as Adam-type methods and shows the best generalization performance in most tasks.

Related Work
The literature in stochastic methods is vast and we review a few very closely related work on improving SGD or Adam. These proposed methods can simply be summarized into two centralizes the second order momentum in Adam. To our best knowledge, there exists several methods achieving different adaptivity from Adam-type methods in SGD. AdaGD Malitsky and Mishchenko [2017] focuses on the local geometry and use the gradients of the latest two steps to adaptively adjust learning rates, which has a convergence only depending on the local smoothness in a neighborhood of the local minima. Besides, AEGD Liu and Tian [2020] is closest to our work which uses the same composite function of the loss with ours: f (x) + c where f is the loss and c is a constant s.t.
f (x) + c > 0 for all x in the feasible region. However, the intuition for AEGD which is far different from our method is to realize a gradient descent with the stable energy which is defined as the above composite function of the loss. Note that the energy of AEGD equals the definition just in the first step and updates in a monotonous way as the algorithm proceeds. Hence, the stable energy seems meaningless because that it unconditionally decrease over iterations.
Notation For a vector θ ∈ R d , we denote its i-th coordinate by θ i . We use θ t to denote θ in the t-th iteration and use θ t,i for the i-th coordinate of θ in the t-th iteration. Furthermore, we use || · || to denote l 2 -norm and use || · || ∞ to denote l ∞ -norm. Given two vectors v, w ∈ R d , we use vw to denote element-wise product and use v 2 to denote element-wise square. We use w v to denote element-wise division.

DecGD
As summarized before, one with aim to improve SGD performance in machine learning and deep learning tasks should consider the following three directions: improving descent directions, a nonuniform scale, and a combination with the learning rate decay scheduling technique. Momentum based methods pay attention to the first aspect, while adaptive methods make efforts to achieve adaptivity with element-wise operations motivated by the second direction. In particular, the dominant adaptive methods are Adam-type methods such as Adam, AdaBound and AdaBelief which employ the second raw moment or second central moment of stochastic gradients, also called EMA mechanism, to achieve adaptivity. However, although many efforts have been spent on the generalization ability, there is not enough evidence showing that Adam-type methods could generalize better than SGD. Therefore, SGD may need a new and different adaptivity.
In the light of this background, we propose a new adaptive variant of SGD, called DecGD, which decomposes gradients into the product of two terms including surrogate gradients and loss based vectors. DecGD achieves new adaptivity in SGD with the loss based vectors and the pseudo-code is shown in Algorithm 1.
Algorithm 1 DecGD (default initialization: c = 1, γ = 0.9, η = 0.01, AMS=False) Input: (update the parameters) end for Intuition The intuition for DecGD is that the loss can help to adjust learning rates over iterations. As the algorithm proceeds, typically one need to adjust the learning rates for convergence. Thus, the learning rate decay scheduling technique is often applied into the training process. Note that both momentum based methods and adaptive methods benefit from the combination with the learning rate decay scheduling technique. Hence, adjusting learning rates according to the loss information is feasible. DecGD employs a decomposition of gradients to access the loss information.
Gradient Decomposition Consider a composite function of the loss f (x): where the objective loss f (x) is a lower bounded function and c > 0 is a constant s.t. f (x) + c > 0, ∀x ∈ X ⊆ R d . Take the derivative of g(x) and we can decompose the gradient ∇f (x) into the product of two terms where ∇f (x) and ∇g(x) are the gradient of f (x) and g(x) respectively. Note that g(x) which has the same monotonicity with f (x) includes the current information of the loss, and ∇g(x) is a scaled version of ∇f (x) with a factor 2g(x) which is a constant for a certain x. Thus, −∇g(x) is also a descent direction because we have −∇g(x)∇f (x) = −(∇f (x)) 2 /2g(x) < 0 where g(x) > 0, ∀x ∈ X . In conclusion, we decompose the gradient of the loss f (x) into a surrogate gradient ∇g(x) which is a descent direction for optimizing f (x) and a loss scalar g(x).
Update Rules Based on the above decomposition, we show the update rule of DecGD. To determine an optimizer, all we need is calculating the learning rate (step size) and searching the update direction. For example, the update scheme of vanilla SGD is: First, we consider the update direction of DecGD. As mentioned above, −∇g(x) is the descent direction which is actually the scaled vector of the steepest descent direction. We employ the momentum to achieve acceleration: where m t+1 , m t ∈ R d , a constant γ ∈ (0, 1) control the exponential decay rate and the initialization m 0,i = 0, i = 1, 2, · · · , d. The above formula shows how to update the direction of DecGD.
We next consider calculating the learning rate of DecGD. In machine learning and deep learning optimization problems, the learning rate at a certain time step is often a constant rather than calculated by traditional line search for the sake of computing cost. To avoid the second issue of SGD, the learning rate often multiplies a vector element-wisely for adaptivity. DecGD, motivated by the learning rate decay scheduling technique, employs a loss based vector which comes from the loss scalar in the above gradient decomposition and has the following update rule where the initial vector v 0,i = g(x 0 ), i = 1, 2, · · · , d. Note that applying the loss scalar g(x), which is the second term of the gradient decomposition, directly results in two disadvantages: First, g(x) is a scalar for a certain x so that we fail to achieve a non-uniform adaptive learning rate. Besides, if so, DecGD would exactly equal to SGD or SGD with momentum. Therefore, we employ the first order Taylor polynomial to approximate g(x) linearly to achieve the approximate loss. In detail, we start with a vector with the initial value g(x 0 ) and update it element-wisely to get a non-uniform loss based vector v in various directions. The update rule 6 can be viewed as the momentum version of the first order Taylor polynomial. With the same aim as AMSGrad, DecGD provides a switch on whether to rectifies v t to ensure that v would not increase in a fairly vast way.
DecGD employs the following scheme to update parameters based on the above decomposition Finally, we note that the computing complexity and the time complexity of DecGD are both O(d) which is same with Adam. However, DecGD has one less parameter than Adam (the 'AMS' in Adam is whether to enable AMSGrad).

Relevance and Difference
With the same aim to achieve adaptivity in SGD, DecGD and Adamtype methods all employ element-wise operations to scale the learning rates non-uniformly and apply momentum to update directions. Differently, Adam-type methods have been working on using the square gradients to approximate the Hessian to obtain second-order information. In particular, AdaBelief Zhuang et al. [2020], which centralizes second order momentum, considers the variance in gradients. In fact, it is a kind of approximation of Hessian to achieve second order information. AdaGD Malitsky and Mishchenko [2017] considers the local Lipschitz constant which is similar to AdaBelief actually. However, it is very different that DecGD considers a zero order information motivated by the practical application. It seems that we can integrate DecGD with Adam-type methods to achieve both zero order and second order approximate information for better convergence.
This topic remains open.

Convergence Analysis
We discuss the convergence of DecGD in both convex and non-convex situations. . This situation is more in line with actual scenarios of machine learning and deep learning tasks.

Online Convex Optimization
In online optimization, we have a loss function f t : X → R. After a decision x t ∈ X is picked by the algorithm, we have the following regret to minimize: The standard assumptions Duchi et al. [2011], Reddi et al. [2018], Hazan [2019], Alacaoglu et al. [2020] in the setting of online convex optimization are as follows: We propose the following lemma: If f t has bounded gradients, then l t has bounded gradients too and is bounded in the feasible regions. Remark 1. The above lemma shows that two terms from the decomposition of the gradient ∇f t (x) are both bounded. In particular, the assumption (3) in the standard assumptions 1 yields Therefore, we can get the following assumptions for DecGD which are entirely yielded from the standard assumptions 1: The key results are as follows: Theorem 1. Under the Assumption 2, let γ ∈ (0, 1) and η t = η √ t , η > 0, DecGD has the following bound on the regret: The following result falls as an immediate corollary of the above results: Corollary 1. Suppose γ has a decay with factor λ t−1 in Theorem 1, we have Corollary 2. Under the same assumptions of Theorem 1, DecGD has the following average regret of convergence:

Stochastic Non-convex Optimization
We discuss the convergence in the stochastic non-convex learning which is more in line with actual scenarios of machine learning and deep learning tasks than the online convex optimization. The standard assumptions Zhuang et al.
Similarly, the above assumptions yield the following assumptions for DecGD according to Lemma 1: (2) The noisy gradient is unbiased, and has independent noise, i.e.
(3) At step t, the algorithm can access a bounded noisy gradient, and the true gradient is also bounded, i.e. ||l t || ≤ L, ||ĝ t || ≤ G,ĝ t is the noisy gradient of l t = √ f t + c, ∀t > 1.
The key result is as follows: Theorem 2. Under the Assumption 4, let γ t < γ ≤ 1, ||v T || 1 ≥ c and η t = η √ t , η > 0, DecGD satisfies where C 1 , C 2 , C 3 are constants independent of d and T , C 4 is a constant independent of T .

Experiments
In this section, we study the generalization performance of our methods and several representative optimization methods. Except SGD with momentum (SGDM), we additionally test two families of optimizers including Adam-type methods and other adaptive methods. The former includes Adam, AMSGrad, AdaBound, AdaBelief and the latter includes AEGD and our method DecGD. We conduct experiments in popular deep learning tasks for testing the performance in thestochastic situation. Particularly, several neural network structures will be chosen including multilayer perceptron, deep convolution neural network and deep recurrent neural network. Concretely, we focus on the following experiments: multilayer perceptron (MLP) on MNIST dataset Lecun et al. [1998]     MLP is a fully connected neural network with only one hidden layer and total epoch is 100. Figure  1(b) shows the empirical result. Note that all optimization algorithms achieve a test error below 2% and our method DecGD and AMSGrad achieve slightly better performance than other methods on the test set.
ResNet-34 and DenseNet-121 on CIFAR-10 CIFAR-10 is a more complex dataset than MNIST. We use more advanced and powerful deep convolution neural networks, including ResNet-34 and DenseNet-121, to test various optimization methods in this classification task on CIFAR-10 dataset. We employ the fixed budget of 200 epochs, set the mini-batch size to 128. Figure 1(c) and 1(d) show the empirical results. Code is modified from the official implementation of AdaBelief and except AEGD and DecGD, data of other optimizers are reported in Zhuang et al. [2020]. As expected, the overall performances of each algorithm on ResNet-34 are similar to those on DenseNet-121. We note that DecGD shows the best generalization performance on DenseNet-121. For ResNet-34, the error of DecGD is slightly lower than that of AdaBelief with a margin 0.07% which is the best performance; For DenseNet-121, DecGD surpasses AdaBelief with a margin 0.13%. We find that classical adaptive methods show rapid descent in the early period of training such as Adam and AdaBound. However, they show mediocre generalization ability on the test set. The empirical results show that our method overcomes the above drawback and achieves even better generalization performance than SGDM.
ResNet-34 and DenseNet-121 on CIFAR-100 CIFAR-100 is similar to CIFAR-10, but the total class is up to 100. Therefore, CIFAR-100 is more difficult and more close to the reality than CIFAR-10. We choose the same structures ResNet-34 and DenseNet-121. We employ the fixed budget of 200 epochs, set the mini-batch size to 128. Figure 1(e) and 1(f) show the empirical results. Code is modified from the official implementation of AdaBelief. Note that DecGD achieves the best generalization performance both in ResNet-34 and DenseNet-121. Concretely, DecGD surpasses AdaBelief with a margin 1.79% in ResNet-34 and a margin 0.51% in DenseNet-121. DecGD shows the generalization ability far beyond other methods on CIFAR-100.
Robustness to c change Considering the popularity of classification tasks, we test the performance of different c for better application of DecGD in these tasks. We select ResNet-18 on CIFAR-10 dataset and c is chosen from {10, 1, 1e − 3, 1e − 8}. Figure 1(a) shows the result. Note that DecGD is robust to different c and the default value c = 1 achieves the slightly better performance. As a sequence, we use the default c = 1 for almost all deep learning experiments.
LSTMs on Penn Treebank dataset We test our method on Penn Treebank dataset with one-layer LSTM, two-layers LSTM and three-layers LSTM respectively. We follow the setting of experiments in AdaBelief Zhuang et al. [2020]. One difference is that AdaBelief improves these experiments by setting learning rate scheduling at epoch 100 and 145 in their official implementation. Except our methods, the results of other methods are reported in AdaBelief. Code is modified from the official implementation of AdaBelief. The perplexities (ppl) of methods are reported in Figure 1(g), 1(h) and 1(i) except AEGD and AMSGrad due to their worse performances. To our knowledge, AdaBelief has been the best optimizer on Penn Treebank dataset. Note that our method DecGD achieves the similar performance to AdaBelief in all three experiments: For one-layer LSTM, DecGD surpasses AdaBelief and achieves the lowest perplexity; For two-layers LSTM, DecGD and AdaBelief show the best performance and DecGD is higher than AdaBelief by a margin 0.28; For three-layers LSTM, DecGD shows the lower perplexity than other methods except AdaBelief and is higher than AdaBelief by a margin 0.73. Considering perplexities equal to e loss , the gap between AdaBelief and DecGD is very small.

Analysis
We select the popular tasks of computer vision and natural language processing to investigate the generalization performance of our proposed methods. As shown above, DecGD, as a new adaptive method, shows an excellent generalization performance which is even better than SGDM. Besides, DecGD is robust to hyperparameters and achieves the best performance with the default learning rate in most cases, especially on CIFAR-100 dataset.

Conclusion
We have introduced DecGD, a simple and computationally efficient adaptive algorithm for non-convex stochastic optimization. This method is aimed towards large-scale optimization problems in the sense of large datasets and/or high-dimensional parameter spaces such as machine learning and deep neural networks. The practical intuition and excellent performance of DecGD show that our method is worth further research.
Despite excellent performance of our method, there still remains several directions to explore in the future: • First, we prove a O(log T / √ T ) bound of our method DecGD in non-convex setting. However, empirical results show that the generalization performance of DecGD is better than many methods with a similar bound such as Adam. A tighter regret bound of DecGD needs to be explored in the future.
• Furthermore, as mentioned before, DecGD and Adam can be integrated with each other.
This topic remains open.
• Finally, several works aim to find a new way to generate adaptive learning rates different from Adam-type methods. Thus, as this kind of works increase, how to measure the quality of adaptive learning rates is more and more important. However, there are few works on this topic.

Broader Impact
Optimization is at the core of machine learning and deep learning. To our best knowledge, there exists few works on different adaptivity from Adam-type methods or EMA mechanism. DecGD shows better performance than those methods. DecGD can boost the application in all models which can numerically estimate parameter gradients.
First, consider l t (x t ) is bounded and ∇l t (x t ) is unbounded, the only possible case is that l t (x t ) → 0, ||∇l t (x t )|| → ∞. Obviously, this case doesn't exist because if l t (x t ) → 0, l t must have gradients with a limit of 0.
Second, consider ∇l t (x t ) is bounded and l t (x t ) is unbounded, the only possible case is that l t (x t ) → ∞, ||∇l t (x t )|| → 0. However, if l t (x t ) has gradients with a limit of 0, l t (x t ) must be finite. Thus, this case doesn't exist too.
Finally, the only case is that l t (x t ) is bounded and ∇l t (x t ) is bounded too. This proves that if f t has bounded gradients, then l t has bounded gradients too and is bounded in the feasible regions.

B Proof of Theorem 1
Proof. We first replace the element-wise product with the dialog matrix and obtain If AMS is true, V t is monotonic decreasing. We aim to minimize the following regret: Let x * ∈ X be the optimal solution, the above regret is where the last inequality follows Cauchy-Schwarz inequality and Young's inequality.
Thus, we obtain and the regret is as follows: We divide the right formula into three parts: Consider the part 1 and apply Assumption 2: Then, the part 2 is as follows: Finally, we give the upper bound of the part 3 by applying Assumption 2: Hence, we get the final regret bound:
where C 1 , C 2 , C 3 are constants independent of d and T , C 4 is a constant independent of T .
We note that Theorem 3.1 in [3] gives the convergence bound for generalize Adam [3]. However, this general framework needs no EMA mechanism, i.e. squared gradients and represents more general adaptivity which uses first order gradients. DecGD belongs to this general framework with 1/ √ v t in this general framework corresponding to v t in DecGD. Therefore, we can apply the above theorem to our proof of DecGD.
Proof. According to the above theorem and Assumption 4, we obtain where C 1 , C 2 , C 3 are constants independent of d and T , C 4 is a constant independent of T .
We divide the right formula to three parts: First, we give the upper bound of the part 1 according to Assumption 4: where the last inequality is due to T t=1 1/t ≤ 1 + log T . Then, consider the part 2: Finally, the part 3 is as follows: Hence, we obtain Now we lower bound the LHS. With the assumption ||v T || 1 ≥ c, we have and thus We finally obtain: This proves Theorem 2.

F Details of Experiments
In this section, we give the details of the experiments reported in the body and show the extensive experiments for better understanding of our method DecGD.

F.1 Details of Classification Tasks
MNIST We employ a three-layers full connected neural network to test the performance of various methods. The batch size is 128 and there is no trick applied to various methods due to the low difficulty of this task. The total epoch is 100.

CIFAR-10
We follow the setting reported in AdaBound and AdaBelief. Moreover, the results of methods except AEGD and DecGD is exactly equal to the results reported in AdaBelief. For AEGD, we search the best learning rate in [0.1, 0.05, 0.01, 0.005, 0.001] and use the recommended hyperparameters. For our method DecGD, all hyperparameters including the learning rate is default without tuning. The weight decay factor is 5e − 4 which is consistent with AdaBound and AdaBelief. We employ the milestone learning rate decay scheduling at epoch 150, which is reported in AdaBelief and AdaBound. The total epoch is 200. This task can be viewed as the replication of experiments reported in AdaBelief, and we aim to achieve the fairest comparative experiments for all methods.

CIAFR-100
The setting of two tasks is exactly same. We follow the setting reported in Ad-aBound and AdaBelief. Moreover, the results of methods except AEGD and DecGD is exactly equal to the results reported in AdaBelief. For AEGD, we search the best learning rate in [0.1, 0.05, 0.01, 0.005, 0.001] and use the recommended hyperparameters. For our method DecGD, all hyperparameters including the learning rate is default without tuning. The weight decay factor is 5e − 4 which is consistent with AdaBound and AdaBelief. We employ the milestone learning rate decay scheduling at epoch 150, which is reported in AdaBelief and AdaBound. The total epoch is 200. This task can be viewed as the replication of experiments reported in AdaBelief, and we aim to achieve the fairest comparative experiments for all methods.

F.2 Details of Language Tasks
Penn Treebank The experiments on Penn Treebank dataset are to test the performance of various methods with RNN. The models are one layer, two layers and three layers LSTM which are famous representatives of RNN. The setting is exactly same as that reported in AdaBelief. The total epoch is 200 and we employ the milestone learning rate decay scheduling at epoch 100 and 145 which is reported in the official implementation of AdaBelief. However, AMSGrad and AEGD show bad performance and need more efforts on tuning hyperparameters and learning rates. We will add the results of them in the future. For DecGD, considering the learning rate of SGD is up to 30, and we follow this setting to use a big learning rate in early training and increase the default learning rate to 0.3 for LSTMs. The weight decay factor we used is reported in AdaBelief.

F.3 Robustness to Hyperparameters
We test various c in the body and report the setting of experiments. Robustness of other hyperparameters such as AMS and learning rates will be test in the future.
c Note that c is the most important hyperparameter in DecGD. We test different c in a popular task: ResNet-18 in CIFAR-10. The learning rate is default, and we follow the setting reported in AdaBelief including weight decay and learning rate scheduling. At least for zero-lower-bounded loss functions, DecGD is robust to c change and 1 is a good default initialization. We will test more functions with different lower bounds in the future.

F.4 Numerical Experiments
We conduct numerical experiments on the two classical high-dimensional functions, Extended Powell Singular function and Extended Rosenbrock function, to test the performance of our method in a convex and non-convex function respectively. The former is a high-dimensional convex function, but the Hessian has a double singularity at the solution so that in the global optimization literature this function is stated as a difficult test case. Extended Powell Singular function is as follows: where we set N = 100 and the initial point is (3, −1, 0, 1, 3, −1, 0, 1, · · · , 3, −1, 0, 1) T . The exact optimal solution is (0, 0, · · · , 0) T and the exact minimum value of Extended Powell Singular function is 0. The latter, Extended Rosenbrock function, is a famous high-dimensional non-convex function in optimization. It has the following form: where we set N = 1000. We start with initial point x 0 = (−1.2, 1, −1.2, 1, · · · , −1.2, 1) T to find the optimal solution. The exact optimal solution is (1, 1, · · · , 1) T and the exact minimum value of Extended Rosenbrock function is 0.
We test Adam and our method DecGD in these two functions and the learning rates are 1e − 3 for Adam and 1e − 5 for DecGD. The results are reported in Figure 2(a). We note that DecGD converge faster than Adam with even smaller learning rates. However, DecGD shows more oscillation and zigzag than Adam. How to reduce them remains open.