Why Transformers Need Adam: A Hessian Perspective

Authors: yushun  zhang
congliang  chen
tian  ding
ziniu  li
ruoyu  sun
zhi-quan  luo
Venue: NeurIPS_cc_2024_Conference
Published: 2024-05-09 18:47:33

Abstract: SGD performs worse than Adam by a significant margin on Transformers, but the reason remains unclear. In this work, we provide an explanation through the lens of Hessian: (i) Transformers are "heterogeneous'': the Hessian spectrum across parameter blocks vary dramatically, a phenomenon we call "block heterogeneity"; (ii) Heterogeneity hampers SGD: SGD performs worse than Adam on problems with block heterogeneity.  To validate (i) and (ii), we check various Transformers, CNNs, MLPs, and quadratic problems, and find that SGD can perform on par with Adam on problems without block heterogeneity, but performs worse than Adam when the heterogeneity exists. Our initial theoretical analysis indicates that SGD performs worse because it applies one single learning rate to all blocks, which cannot handle the heterogeneity among blocks. This limitation could be ameliorated if we use coordinate-wise learning rates, as designed in Adam.

Main paper: 
 introduction: 
 Transformers [83] have become a major workhorse behind AI development (e.g., [1] ). However, the understanding of Transformer training remains limited. For instance, Transformer training largely relies on the Adam optimizer [45, 57] . In contrast, stochastic gradient descent with momentum (SGD) 2 , the de-facto optimizer for convolution neural networks (CNNs) [49] , performs significantly worse than Adam on Transformers (e.g., Figure 3 ). Yet, the reasons behind this performance gap remain unclear. Understanding why SGD performs worse than Adam on Transformers is an intriguing question. First, from a theoretical perspective, this can help us better understand the training of Transformers and more generally, neural networks. Second, from a computational perspective, the understanding may inspire the design of better algorithms for training neural networks.In this work, we explore why SGD largely underperforms Adam on Transformers through the lens of Hessian. We start by investigating the full Hessian spectrum of Transformers, i.e., the full eigenvalue density of Hessian (see Figure 1 ). By theory, the full Hessian spectrum largely determines the behavior of gradient-based methods [63, 33, 79, 37] , so we suspect it may also help explain SGD's unsatisfactory performance. Using tools from numerical linear algebra [7] , we empirically compare the full spectra of CNNs (where SGD is on par with Adam) and those of Transformers (where SGD largely lags behind Adam). Unfortunately, as shown in Figure 1 , the spectra for CNNs and Transformers are often largely similar despite the different optimizer behaviors. As such, we have not identified critical features in the full Hessian spectra associated with the gap between Adam and SGD on Transformers. To reveal the cause, a more fine-grained investigation into the Hessian is needed. What would cause SGD to perform significantly worse than Adam on Transformers, but not on CNNs? By dissecting the structures of CNNs and Transformers, we notice that CNNs are constructed by the repetitive stacking of similar parameter blocks (convolution layers), while Transformers involve the non-sequential stacking of disparate parameter blocks (e.g. Query, Key, Value, Output projection blocks in attention and MLP layers). We hypothesize that these architectural differences might lead to different optimization properties. Intuitively, disparate parameter blocks contribute differently to the overall loss. So each block might benefit from a specialized treatment by optimizers, a flexibility offered by Adam but not by SGD. This observation motivates us to investigate the Hessian spectrum of each parameter block, which we refer to as the blockwise Hessian spectrum.By inspecting the blockwise Hessian spectrum, we discover a possible explanation for why SGD is worse: the "heterogeneity" inherent in Transformers. We provide both empirical and theoretical evidence to support this explanation. Our contributions can be summarized as follows:• Why SGD underperforms Adam on Transformers. We explain why SGD is worse than Adam on Transformers by examining the blockwise Hessian spectrum. First, we identify a phenomenon called "block heterogeneity", which refers to the large differences in the Hessian spectra across parameter blocks. This block heterogeneity is observed in all examined Transformers but not in CNNs. Second, we verify that block heterogeneity hinders SGD. Across various Transformers, CNNs, and MLPs, we show that SGD consistently performs worse than Adam on problems with block heterogeneity but can perform similarly to Adam, otherwise.• Theoretical results on quadratic models. We construct convex quadratic problems with and without block heterogeneity and find that gradient descent (GD) largely underperforms Adam on problems with block heterogeneity, but can perform comparably otherwise. Our theoretical analysis shows that GD can be slower than Adam on quadratic problems with block heterogeneity. We point out GD is slower than Adam because it uses a single learning rate for all blocks. The deficiency can be mitigated by assigning different learning rates across blocks, as Adam does. We emphasize that we do not claim block heterogeneity is the only cause for the performance gap between Adam and SGD, but just that it is at least one important cause. We verify, both empirically and theoretically, that SGD underperforms Adam when block heterogeneity is present.2 Problem Settings and Initial Attempts 2.1 Problem Settings Notations. We denote the training loss as L(w), where w ∈ R d is the neural network parameters. We denote the gradient and Hessian of the training loss w.r.t. neural network parameters as ∇L(w) ∈ R d and ∇ 2 L(w) ∈ R d×d , respectively. We use [d] to denote the index set {1, 2, • • • , d}. Given an arbitrary partition {D l } L l=1 over [d] with d l ≜ |D l |, we can split w into L parameter blocks {w l } L l=1 , where w l = R d l consists of parameters with indexes in the l-th block D l . We denote [∇ 2 L(w)] l ∈ R d l ×d l as the Hessian of l-th parameter-block w l , where [∇ 2 L(w)] l,i,j = ∂ 2 ∂w l,i ∂w l,j L(w l ). Note that [∇ 2 L(w)] l is the l-th principal block sub-matrix of ∇ 2 L(w).Setups. Hessian of large-scale NNs are intractable to compute and store. In this work, we apply a numerical tool called Stochastic Lanczos Quadrature method (SLQ) [7] to approximate the Hessian spectrum. SLQ uses a smooth curve on R to approximate the histograms of eigenvalues (see Figure 1 as an example). A detailed introduction to SLQ is provided in Appendix C.2. All experimental setups are shown in Appendix D. We focus primarily on the following models/tasks.• CNNs. We study ResNet18 (11M) and VGG16 (138M) on ImageNet [40, 78] . On these tasks, SGD performs on par with Adam. See Figure 9 in Appendix B for the evidence. • Transformers. We study Transformer with various scales and modalities, including GPT2 (125M)on OpenWebText [71] ; ViT-base (86M) on ImageNet [27] ; BERT (40M) on Cornell Movie-Dialogs Corpus [25] ; GPT2-nano 3 (11M) on English corpus. On these tasks, SGD performs significantly worse than Adam. See Figure 10 in Appendix B for the evidence.For each model, we estimated (1) the full Hessian spectrum ∇ 2 L(w), and (2) the blockwise Hessian spectrum [∇ 2 L(w)] l , l ∈ [L]. For the latter, we split w according to the default partition in PyTorch implementation, e.g., Embedding layer, Query in each attention layer, Key in each attention layer, Value in each attention layer, etc. Note that the term "block" differs from the term "layer". For instance, Query and Key can reside in the same layer but are different parameter blocks. 
full hessian spectrum is not informative enough: 
 We study the full Hessian spectrum of Transformers for two reasons. First, as stated in Section 1, the Hessian spectrum significantly influences the behavior of gradient methods [63] . Second, previous research shows that the Hessian spectrum provides insights into neural network phenomena, like BatchNorm's effect on training speed [32] . Therefore, we hypothesize that the Hessian spectrum may also explain why SGD largely lags behind Adam on Transformers.We compare the full Hessian spectra of CNNs (where SGD performs similarly to Adam) and those of Transformers (where SGD underperforms Adam), as shown in Figure 1 . Unfortunately, the results suggest that the full Hessian spectrum alone may not suffice to explain the gap between Adam and SGD on Transformers. We elaborate as follows. The primary information in the spectrum lies in its (A) dispersion, (B) shape, and (C) evolution during training. Regarding (A), we observe that the eigenvalues are dispersed similarly across different models, with no notably large outlier for Transformers. Thus, dispersion does not seem to be related to why SGD is worse than Adam. We further investigate (B) and (C). For all CNNs and Transformers in Figure 1 , we observe similar phenomena: the spectrum's shape is approximately symmetrical around 0 at initialization. As training proceeds, the majority of negative eigenvalues disappear, and the shape evolves into a combination of a "bulk" and some "outliers". Since the spectral shape and evolution are quite similar for both Transformers and CNNs, they cannot explain why SGD is worse than Adam on Transformers, either.In summary, we have not identified any critical phenomena in the full Hessian spectra that can be linked to the performance gap between Adam and SGD on Transformers.What other factors could cause SGD to perform significantly worse than Adam on Transformers but not on CNNs? We identify one critical feature that has been overlooked in the full Hessian spectrum analysis above: the building-up rules of Transformers. As shown in Figure 3 , CNNs are constructed by the repetitive stacking of similar parameter blocks (convolution layers). In contrast, Transformers consist of disparate parameter blocks, e.g. Query, Key, Value in attention, and MLP layers. Further, these blocks are stacked in a non-sequential manner. We hypothesize that the "different designs among parameter blocks" can be reflected in the Hessian of these parameter blocks, which might affect algorithmic behavior. This inspires us to investigate the blockwise Hessian spectra, i.e., the spectrum of principal blocks of Hessian[∇ 2 L(w)] l , l ∈ [L].In parallel to the motivation above, we further provide another evidence that blockwise spectra might be helpful. Classical literature showed that the Hessians of neural nets are near-block-diagonal matrices [18] , i.e., the magnitudes in the Hessian principle blocks are much larger than those in the off-diagonal blocks. We restate their findings in Figure 2 (a). This implies that the majority of Hessian information indeed lies in its principle blocks, and the blockwise Hessian of neural nets might contain valuable information.To summarize, the "heterogeneous" building-up rules of Transformers inspire us to check the blockwise Hessian, i.e., the principle blocks of the Hessian. The classical results of neural nets [18] further support us to explore this direction since they find that the majority of Hessian information indeed lies in its principle blocks. In the following, we study the blockwise Hessian spectra of various neural networks. For ease of implementation, we define parameter blocks under the PyTorch partition. We show that the blockwise spectra indeed carry more information than the full spectrum for distinguishing CNNs and Transformers.Remark: why near-block-diagonal? We briefly restate the analysis in [18, Section 7] to explain the near-block-diagonal Hessian structure of neural nets. Consider minimizing ℓ(f (θ, x), y) where ℓ(•, •)is the Cross-Entropy (CE) loss, f (θ, x) = n i=1 v i ϕ(w ⊤ i x) is an 1-hidden-layer neural network with input x ∈ R d , weight w i ∈ R d , v i ∈ R,and label y ∈ {0, 1}, then the off-diagonal-block Hessian elements will containEQUATIONwhere p θ (y|x) = 1/(1 + exp(-yf (θ, x))) and ϕ ′ (•) is the derivative of ϕ(•). Note that the term p θ (y|x) (1 -p θ (y|x)) will vanish rapidly since the training objective is to maximize p θ (y|x). Consequently, this drives the Hessian towards a near-block-diagonal configuration, with each block representing an output neuron. This result is validated in Figure 2 : we find that the near-blockdiagonal structure appears at 1% step and it maintains along the training.3 Main Results 
transformers exhibit block heterogeneity in hessian, while cnns do not: 
 We now compare the shape of blockwise spectra in VGG16 [40] (CNN) and BERT [25] (Transformer). We sample four blocks for each model and present the spectra in Figure 3 . In BERT, the spectra of embedding, attention, and MLP blocks are largely different. In contrast, in ResNet, the spectra of convolution layers are similar. We further verify this observation for the rest of the parameter blocks. We calculate the Jensen-Shannon (JS) distance between two eigenvalue densities of all possible block pairs and show the results in Figure 4 . We summarize our findings in Observation 1. Figure 4 : The JS distance among blockwise Hessian spectra at initialization. We find that the JS distance of blockwise spectra in CNNs is significantly smaller than that in Transformers.Observation 1: For all Transformers we checked, the blockwise Hessian spectra are largely different from each other. In contrast, the blockwise Hessian spectra of CNNs are similar.In the following, we refer to the phenomenon of Transformers as "block heterogeneity", and refer to that of CNN as "block homogeneity". The observations in Figure 3 and 4 indicate that block heterogeneity is informative in distinguishing CNNs and Transformers. In the following, we will show that the block heterogeneity is strongly correlated with the performance gap between SGD and Adam on Transformers. (2) Transformers have block heterogeneity. Now we further link block heterogeneity to SGD's unsatisfactory performance on non-Transformer models. This would directly establish a connection between "block heterogeneity" and "why SGD is worse than Adam", without going through Transformers or attention blocks as an intermediary. We consider one man-made example and one real-world example.Example 1: A man-made MLP. We consider a 4-layer MLP on MNIST and change the degree of heterogeneity by scaling each layer by constant c. Figure 5 (a) shows SGD gradually performs worse than Adam as heterogeneity grows. Example 2: MLP-mixer. We consider MLP-mixer [81] , a famous all-MLP architecture that outperforms CNNs and ViTs on some vision tasks. We summarize the findings so far in Observation 2.Observation 2: For all tasks that we checked, SGD is worse than Adam when block heterogeneity exists, regardless of whether Transformers or attention mechanisms are utilized.We remark that different Transformers exhibit different levels of block heterogeneity. Although all examined Transformers show strong block heterogeneity, we find that this heterogeneity can be mitigated, resulting in less performance deterioration for SGD. As illustrated in Figure 6 , pre-trained GPT2 on SFT tasks can exhibit less block heterogeneity compared to pre-training GPT2 from scratch (Figure 4 (f)). In this case, although SGD is still slower than Adam, it achieves a similar loss at convergence. Compared with training GPT2 from scratch (Figure 10 (d) in Appendix B), the performance gap between SGD and Adam is significantly narrowed down. These findings suggest that the heterogeneity induced by architectural design can be alleviated by selecting "good" weights. This partly explains why simpler methods like SGD and even its zeroth-order version can still be effective for fine-tuning language models, albeit with slower convergence [59, 60] . In Figure 13 in Appendix B, we further report the evolution of the block heterogeneity of ViT-base along the training. Similarly to GPT2 in Figure 6 , we find that the block heterogeneity of ViT-base tends to reduce after the training. In addition, we find that SGD can perform better when initializing at the weight with less heterogeneity, e.g., initializing at 50% total training steps. We hypothesize that "the attenuation of Hessian heterogeneity" is a common phenomenon after training, and we leave detailed investigation as a future direction.Observation 3: Block heterogeneity in Hessian tends to reduce after (pre)-training.We have shown that SGD can largely underperform Adam on various architectures. This leads to an intriguing question: Can we predict the incompetence of SGD before the training begins?Our findings can bring up an empirical guidance: we can compute the blockwise spectrum of initial Hessian, and then decide whether to use Adam or SGD. Such a method could be useful in scenarios in training large models that are not mainstream Transformers or CNNs, e.g., Mamba [38] . In these cases, there is not much prior experience in choosing optimizers. It would be intriguing to decide whether SGD is suitable for the task before the training is launched. One might argue that simple trial is enough: try both SGD and Adam; if Adam is remarkably better, then pick Adam; if Adam and SGD are similar, then pick SGD. Nevertheless, this simple approach may not be easy for large models. First, for large models, it may take days to know one run of an algorthm is good or not. Second, it requires tuning hyperparameters at least a few times to get a reasonably good judgement, making the cost of trial even higher.We here propose a quantitative metric that could predict the incompetence of SGD before the training. With the help of this metric, we could save much expense on the trial and error for SGD. The metric is simply the averaged JS distance among blockwise Hessian spectra at initialization, i.e., the averaged value in the heatmap of Figure 4 . We denote it as JS 0 . We present JS 0 of various models in Table 1 . Note that JS 0 establishes a quantitative difference between the loss landscape of Transformers and CNNs. Further, JS 0 is independent of optimizers and could be checked before training. To validate the effectiveness of the quantitative metric JS 0 , we summarize JS 0 of different models and the corresponding SGD performance in Figure 7 . We find that the performance gap between SGD and Adam becomes greater as JS 0 increases. Thus, JS 0 can serve as a potential indicator to predict whether SGD may underperform Adam.Figure 7 : Comparison of JS 0 and the performance of SGD on different models. We find the performance gap between SGD and Adam becomes greater as JS 0 increases.Finally, we remark JS 0 is rather expensive to compute due to the overhead of SLQ: it requires comparable time to one training run. Fortunately, we find the original SLQ is rather redundant for measuring hessian heterogeneity. We propose some simple tricks to significantly reduce the computation time, while still effectively detecting the Hessian heterogeneity. We call it simplified SLQ and we present it in Table 3 in Appendix B. As a result, the simplified SLQ can obtain the same message as in Table 1 while only taking negligible time (e.g., < 0.001s for ResNet18). 
case study of quadratic models and preliminary theory: 
 Now we study quadratic functions with block diagonal Hessian, with or without block heterogeneity. Note that insights on quadratic models could be important for understanding realistic NNs, as mentioned by researchers such as LeCun et al. [50] and OpenAI team [44] .Setups and additional notations. We consider the following quadratic minimization.min w∈R d L(w) = 1 2 w T Hw -h T w,where H ∈ R d×d is positive definite and h ∈ R d . We denote L * as the minimum value of L(w). We set H as a block diagonal matrix:H = diag(H 1 , • • • , H L ), where H l ∈ R d l ×d l and d = L l=1 d l . We use w l ∈ R d l to denote the variable in the l-th block and w = (w T 1 , • • • , w T L ) T ∈ R d . Similarly for h l ∈ R d l . Similarly, we use [∇L(w)] l ∈ R d l to denote the gradient in the l-th block and denote [L(w)] l = 1 2 (w t l ) T H l w t l -h T l w l as the objective function w.r.t. the l-th block. Note that L(w) = L l=1 [L(w)] l . We denote λ 1 ≥ λ 2 • • • ≥ λ d as the eigenvalues of H. Similarly for λ l,1 • • • λ l,d l . We denote κ = λ1 λ d and κ l = λ l,1 λ l,d las the condition number of H and H l , respectively.We say an algorithm has complexity Õ(C) if it takes O(C log(1/ϵ)) iterations to achieve errorL(w)-L * L(w 0 )-L * ≤ ϵ, where w 0 is the initial point.We consider four types of Hessian H as follows. For all cases, we set condition number = 5000. we constructH l = Q l Λ l Q T lwhere Q l are matrices with i.i.d. standard Gassian entries and Λ l are diagonal matrices. For the diagonal elements in Λ l , we sample d l numbers according to the spectrum of the embedding layer; 3rd Query, 3rd Value, 3rd MLP (fc layer) in GPT2. Shifting and proportional scaling are performed to ensure all elements in Λ l lie in the interval [1, 5000] . This ensures strong convexity and controls the condition number of H equals 5000. The spectra of H l are in Figure 14 in Appendix B. We choose h = 0 for all cases.• Case 2: Hessian with CNN-type spectra. We use the same setup as in Case 1. For the diagonal elements in Λ l , we sample d l numbers according to the spectrum of the 1st to 4th convolution layers in ResNet18. We then shift and scale Λ l to the interval [1, 5000] to ensure strong convexity and a condition number of 5000. The spectra of H l are shown in Figure 15 in Appendix B. • Case 3: Hessian with simplified heterogeneous spectra. We choose L = 3 andd l = 3. For l ∈ [L], we construct H l = Q l Λ l Q T lwhere Q l are independent standard Gassian random matrix and Λ l are diagonal matrices. We set the diagonal elements of Λ l as {1, 2, 3}, {99, 100, 101}, {4998, 4999, 5000} for l = 1, 2, 3, respectively. The spectra of H l are different due to their different supports. The condition number of Hessian H is 5000.• Case 4: Hessian with simplified homogeneous spectra. We consider the same setup as Case 3.We set the diagonal elements of Λ l as {1, 99, 4998}, {2, 100, 4999}, {3, 101, 5000} for l = 1, 2, 3, respectively. The spectra of H l are similar. The condition number is 5000. Now we study two types of optimizers: one that assigns a single learning rate for all blocks, and one that assign different learning rates across blocks.• Single-learning-rate optimizer. We study gradient descent (GD).EQUATIONWe use the optimal learning rate η = 2 µ+L [63] . We use standard Gaussian initialization. • Coordinate-wise-learning-rate optimizer. We study Adam with a constant learning rate and with no bias correction for simplicity (Algorithm 3). We set β 1 = 0 to erase the effect of momentum. This helps us to focus on the effect of coordinate-wise learning rate (or the effect of diagonal preconditioning) in Adam. We use ϵ = 0. We consider β 2 = 1 and β 2 = 0.99, respectively. When β 2 = 1, Adam assigns coordinate-wise learning rates according to the initial gradient, but these learning rates are fixed along iteration. The update rule is as follows.EQUATIONwhereD 0 Adam = diag(∇L(w 0 ) • ∇L(w 0 )) 1 2and ∇L(w 0 ) = Hw 0 -h. When β 2 < 1, the coordinate-wise learning rates adaptively change along iteration. The update rule is as follows (note that ∇L(w k ) = Hw k -h.).EQUATIOND t Adam = diag (1 -β2) t k=1 β t-k 2 ∇L(w k ) • ∇L(w k ) + β t diag(∇L(w 0 ) • ∇L(w 0 )) 1 2We grid search η and use the standard Gaussian initialization. We remark that when β 2 < 1, Adam would bounce among non-optimal points. This will be shown in Proposition 2.Summary of experimental observations. Figure 8 presents two phenomena. For Hessian with heterogeneous blocks (Case 1 and 3), GD largely lags behind Adam. For Hessian with homogeneous blocks (Case 2 and 4), GD is on par with Adam. We emphasize that all Hessians have the same condition number. Further, Hessian in Case 3 and 4 share all the eigenvalues (not just the extreme ones). The gap between Adam and GD is purely due to the different blockwise spectra caused by the different locations of eigenvalues. Case 3 and 4 help reveal the causal relation between "block heterogeneity in Hessian" and "GD is worse than Adam". We hypothesize that GD performs badly because it uses one single learning rate for all blocks, which cannot handle the heterogeneity among blocks. Such heterogeneity can be better handled using different learning rates across blocks, as designed in Adam.We now provide initial theoretical results to characterize how GD lags behind Adam in problems with heterogenous Hessian. Note that classical optimization theory depicts the rate of first-order methods by the condition number of the full Hessian κ. However, we point out that κ is not informative enough to describe the performance gap in Figure 8 since κ is the same in all four cases. To distinguish Adam and GD, we need to utilize more fine-grained quantities like blockwise spectra of sub-matrices.Note that the blockwise spectrum is not common in the optimization area. The most related notion is perhaps "block Lipschitz constant" [8] for studying block coordinate descent (BCD) type methods, but it was not linked to the performance of SGD or Adam before. To our knowledge, we are not aware of any theory of Adam or GD built on the block diagonal structures or the blockwise spectra of Hessian. We now make an initial attempt in this direction. We first present the lower bound for GD. Proposition 1. (Lower bound for GD.) Consider min w L(w) = 1 2 w T Hw -h T w where H ∈ R d×d is positive definite and h ∈ R d . Let w t GD be the output of GD after t steps. There exists a block diagonal matrix H, h and an initial point w 0 , s.t., for any η, we have:EQUATION)where κ is the condition number of H. Proposition 1 shows that GD has complexity Õ(κ) and such complexity is tight. Now we prove that Adam can achieves better complexity. This is because it chooses different learning rates for different block sub-matrix H l via its diagonal preconditinoner D 0 Adam . We consider generic random initialization that covers commonly used distributions such as Gaussian, Uniform, etc. Assumption 1. (Random initialization.) Assume the initialization w 0 is sampled from a continuous distribution, i.e., the probability measure (induced by w 0 ) of any zero-Lebesgue-measure set is 0. Theorem 1. (Upper bound for Adam with β 2 = 1.) Consider the same setting as Proposition 1 and consider Adam with β 1 = 0 and β 2 = 1 as in (3) . Assume the initialization satisfies Assumption 1. Let w t Adam be the output of Adam after t steps. Let η = min l∈[L] 1 C l,1 . Then w.p.1., we haveEQUATIONwhere κ Adam,l = rκ l , κ l is the condition number of H l , constant r relates to w 0 defined as:r = max l∈[L] C 2 l,2 min l∈[L] C 2 l,1, where C l,1 = minEQUATIONThe proofs of the above theorems are shown in Appendix E. Theorem 1 states that Adam (withβ 2 = 1) has complexity Õ r • max l∈[L] κ l .We note that coefficient r depends on the ratio between initial gradient and the principal eigenvalue for each block, and smaller ratio would give faster convergence. We further remark that condition β 2 = 1 is necessary because any β 2 < 1 causes non-convergence issue [10, 21] . We restate their results in Proposition 2. The non-convergence is also observed in Figure 8 (c), where we find that the iterates of Adam quickly converge to near-optimal solutions, and then bounce back. As such, β 2 = 1 is necessary for asymptotic analysis. The analysis for β 2 = 1 is still meaningful since it still shows the effect of Adam's preconditioner.As shown in [21] , the non-convergence is due to the constant learning rate. Reducing the learning rate reduces the gap between L(w t Adam ) and L * , but does not remove it. Proposition 2. (Non-convergence of constant-learning-rate Adam with β 2 < 1.) [21, Proposition 12, Figure 1 ] Consider min w∈R L(w) = 1 2 w 2 . Consider Adam with β 1 = 0 and β 2 < 1 as in (4). Let w t Adam be the output of Adam after t steps. There exists a discrete limit cycle for (4) andlim inft→∞ L(w t Adam ) -L * > 0.We now compare the complexity of Adam and that of GD. By Theorem 1, Adam is faster than GD when r • max l∈[L] κ l ≤ κ. In the quadratic model with heterogeneous blocks (Case 3), our simulation over 1000 trials shows that r ≤ 1000 with probability ≥ 2 3 when using standard Gaussian random initialization. Since max l∈[L] κ l ≈ 1, we have r • max l∈[L] κ l ≤ 1000, w.h.p., and is about 5× smaller than κ = 5000. So Adam could be 5× faster than GD, w.h.p.. This is indeed observed in Figure 8 where Adam outperforms GD by a significant margin. We summarize the complexity of GD and Adam in Table 2 .Remark: some common misconceptions. During the review process, we find that readers might conclude that "Theorem 1 implies Adam under homogeneity has worse complexity than Adam under heterogeneity". We now clarify that this claim is not correct, and there is no conclusion on "whether Adam under homogeneity is faster or slower than Adam under heterogeneity". Similarly, Theorem 1 does not imply "Adam always converges similarly as GD under homogeneity". Though it is observed on CNNs, there is no general conclusion of this kind. For interested readers, we provide a detailed explanation in Appendix B.Table 2 : The complexity of GD and Adam for minimizing a strongly convex quadratic function with block diagonal Hessian. The symbol ✗ means non-convergence. κ and κ l denote the condition number of the full Hessian and the block submatrix, respectively. r is defined in (7) .Optimizer GD Adam with Adam withβ 1 = 0 and β 2 = 1 (3) β 1 = 0 and β 2 < 1 (4) Complexity Õ(κ) Õ r • max l∈[L] κ l ✗How to obtain a tighter complexity bound of Adam? It is valid to ask whether the complexity upper bound in Theorem 1 can be tightened, e.g., improve the factor of r. We point out it would be difficult if there is no extra structure on H l . A key technical step is to bound the condition number of the preconditioned matrix κ (D 0 Adam,l ) -1 H l . Intuitively, a diagonal preconditioner of H l is powerful when H l itself has a near-diagonal structure, e.g., pure diagonal, tridiagonal or diagonal dominant [30] . Unfortunately, it is unclear whether these structures hold in Transformers. Without any assumption on H l , we find that the diagonal preconditioner of D 0 Adam could increase the condition number. For instance, when using standard Gaussian initialization, in case 3, we find κ (D 0 Adam,l ) -1 H l equals 7.09κ 1 , 18.98κ 2 , 18.76κ 3 for the 3 blocks, respectively (all averaged over 1000 trials). It would be interesting to explore if there are special structures of H l in Transformers such that Adam preconditioner can reduce κ l , rather than increase it. We leave it as a future direction.More discussions on the theoretical advantage of Adam. Although Adam preconditioner might not always reduce the "local" condition number κ l , the coefficient in the complexity is now independent of the "global" condition number κ. As argued above, such changes in coefficient could lead to considerable improvement over GD. Such improvement in complexity is attributed to the block diagonal structure in Hessian as well as its heterogeneous blockwise spectrum. To our knowledge, such improvement is not shown in the existing literature. One possible reason is that: for the optimization community, it is very rare to analyze (near-) block-diagonal Hessian structure since typical problems do not have such structure. For instance, in the classical non-linear programming dataset [48] , all problems have non-block-diagonal Hessian. We suggest a different perspective to characterize modern optimization problems. We believe our perspective is new because it is built upon multiple non-trivial findings.In summary, our theory indicates that: for problems with block heterogeneity, the single-learning rate methods like GD can largely lag behind coordinate-wise learning rate methods like Adam.Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)? Answer: [Yes] Justification: In Appendix D, we carefully describe all the needed information to reproduce the experimental results. Guidelines:• The answer NA means that the paper does not include experiments.• If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not. • If the contribution is a dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable. • Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is a specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed. • While NeurIPS does not require releasing code, the conference does require all submissions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example (a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm. (b) If the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully. (c) If the contribution is a new model (e.g., a large language model), then there should either be a way to access this model for reproducing the results or a way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset). (d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. In the case of closed-source models, it may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results. 
conclusion: 
 In this work, we explore why SGD largely underperforms Adam on Transformers. we establish a phenomenon called block heterogeneity in Hessian and link it to the performance gap between Adam and SGD. We numerically verify our claim on various Transformers, CNNs, MLPs, and quadratic problems. Initial theory is also provided to support the claim.Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material? Answer: [Yes] Justification: We provide code in the supplementary materials. Guidelines:• The answer NA means that paper does not include experiments requiring code. • The experimental setting should be presented in the core of the paper to a level of detail that is necessary to appreciate the results and make sense of them. • The full details can be provided either with the code, in appendix, or as supplemental material. Guidelines:• The answer NA means that there is no societal impact of the work performed.• If the authors answer NA or No, they should explain why their work has no societal impact or why the paper does not address societal impact. • Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations. • The conference expects that many papers will be foundational research and not tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster. • The authors should consider possible harms that could arise when the technology is being used as intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology. • If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).Answer: [NA] Justification: Our paper does not involve crowdsourcing nor research with human subjects. Guidelines:• The answer NA means that the paper does not involve crowdsourcing nor research with human subjects. • Including this information in the supplemental material is fine, but if the main contribution of the paper involves human subjects, then as much detail as possible should be included in the main paper. • We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution. • For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review. 
 
 Appendix: On the unsatisfactory performance of SGD on Transformers There is an active line of works that explores why SGD performs significantly worse than Adam on Transformers. One representative hypothesis is that SGD cannot handle the heavy-tailed stochastic noise in language tasks [105] . However, Chen et al. [14] , Kunstner et al. [46] reported that the gap between Adam and SGD maintains even in the full-batch case with no stochasticity, so there might be other reasons. Further, SGD performs worse than Adam on Vision Transformers on ImageNet (See Figure 10 . Also see [92] for more evidence), so the data modality (e.g., language or vision tasks) might not be as crucial as the architecture. [104] showed that NLP tasks have "unbounded smoothness" issue and SGD with gradient clipping performs better than SGD in this case. Although clipping is an effective trick, we still observe a huge gap between clipped SGD and Adam 4 , so there might be other reasons. Different from these works, we find SGD underperforms Adam because it uses one single learning rate for all blocks, which cannot handle the Hessian heterogeneity among blocks.Understanding of Adam. There was once a long-standing debate on the possible divergence of Adam [72] . The convergence for the unmodified versions is later established in [77, 107] for RMSprop and Adam. More convergence analyses of general adaptive gradient methods are listed later in this section. We here focus on the literature that explores the benefit of Adam. Xie et al. [93] show that Adam can help avoid saddle points, which is an orthogonal direction to this work. Wang et al. [84] , Crawshaw et al. [19] , Li et al. [51] show that Adam and its variant outperform SGD under relaxed smoothness conditions, based on the intuition that Adam can adaptively change its learning rate along iteration (over time). We pointed out that the theory is not complete: even for quadratic functions where the smoothness is fixed, SGD sometimes performs largely worse than Adam (Figure 8 ). This indicates that the benefit of Adam is not merely due to its ability to adaptively change the learning rate (over time), and there are other reasons for Adam's success. We show that an important benefit of Adam is its ability to handle the heterogeneity across blocks (over space).Recent works [9, 91, 46, 54, 3] build a relation between Adam and the sign-based methods. Wu et al. [91] further showed that sign-based methods can be effective when the Hessian is diagonal and satisfies several other properties. However, as put by the authors, it seems "unclear to what extent these properties hold for real problems". Pan and Li [66] numerically found that the Adam can reduce the directional sharpness along trajectories, while its relation to fast convergence remains mysterious. A recent work [43] point out that Adam biases the trajectories towards regions where Hessian has "uniform diagonal entries" while SGD cannot. The distribution of Hessian diagonal entries is also investigated in [54] . The theory in [43] implies that Adam is faster when the Hessian is diagonal. However, as argued above, it is unclear whether the diagonal Hessian structure commonly holds in real problems. In fact, we find the Hessian is closer to a block-diagonal (instead of pure diagonal) structure on some small Transformers. In these cases, blockwise eigenvalues carry more information than diagonal entries, providing extra details such as the location of eigenvalues. We find that these extra details are important for distinguishing Adam and SGD.Hessian Spectrum Analysis. There are several important attempts to explore the Hessian spectrum of MLPs and CNNs. Early works [74, 75, 12] found that the Hessian spectra of MLPs and CNNs consist of a "bulk" together with a few "outliers". Papyan [69] , Wu et al. [91] , Liao and Mahoney [52] further characterized the bulks and outliers in theory. Papyan [67, 68] numerically built the relation between these "outliers" and the Gauss-Newton matrix. Sankar et al. [76] numerically explored the relation between Hessian of CNNs and Gauss-Newton matrix in each layer. They further found that most CNN layers contribute similarly to the overall loss surface. We find that this result is restricted to CNNs and does not hold on Transformers due to the heterogeneity. Gur-Ari et al. [39] showed that for MLPs and CNNs, gradient descent converges to a small subspace spanned by a few top eigenvectors of the Hessian. Yao et al. [97] , Zhang et al. [103] explored the relation between the Hessian spectrum of CNNs and some training phenomena such as the effect of batch sizes. Ghorbani et al. [32] , Yao et al. [98] focused on explaining the effectiveness of techniques such as BatchNorm. Note that all these works are restricted to MLPs and CNNs, while we study the Hessian of Transformers (in addition to CNNs and MLPs) as well as its impacts on different optimizers.On the difficulties of Transformer training. Transformers are known to be difficult to train. Researchers have attributed the training difficulties to various phenomena in different components of Transformers, including: the logits divergence or the rank degeneracy in the outputs of attention layers [26, 65, 90, 101, 24, 17] ; the growth of parameter norm in attention layers [61] ; over-reliance on residue branches [56] ; and some negative impact of layer norm [15, 102, 41] . These phenomena have a strong correlation with gradient vanishing or explosion in Transformers [102, 56, 41, 94, 65, 87, 90, 62] , which leads to training difficulties.Several solutions have been proposed. Liu et al. [56] numerically observed that adaptive gradient methods can (partly) overcome gradient vanishing by giving "consistent update magnitude", while it seems unclear how consistent update magnitude would help optimization in principle. Researchers further develop training tricks such as warmup learning rate [55, 94] , temperature scaling [65] , better initialization [102, 41, 87, 5, 96] , and variants of Layer Norm [64, 88, 94, 87, 24] . Recent researchers also suggest using z-loss regularization [17, 95] and tuning hyperparameters of Adam [107, 90] . All these tricks can help mitigate gradient explosion or vanishing. Nevertheless, training large-scale Transformers remains challenging [106, 100, 90, 62, 17] . Different from all aforementioned works, we investigate the training difficulties of Transformers through the eigenvalues of Hessian. We establish a strong correlation between "the blockwise Hessian spectra of Transformers" and "why SGD largely underperforms Adam on Transformers". We realize that our attempt is just a first step towards understanding Transformer training, and we believe there is rich information hidden in Hessian and we leave more fine-grained analysis as future works.There is extensive convergence analysis for adaptive gradient methods. For instance, researchers study the convergence of AMSGrad [72, 108] , RMSprop [99] , AdaFom [16] , AdaBound [58] , and Adam with iterate-dependent hyperparameters [109, 13, 31] . The convergence of Adam is also explored in [23, 85] . There is also an active line of theoretical research on the convergence of AdaGrad [28] , we recommend [86] for more detailed introduction. In this work, we do not focus on the convergence analysis. Rather, we explore the quantitative difference between the loss landscape of CNNs and Transformers and how it impact the behaviors of SGD and Adam.Performance comparison of AdamW and SGD on different Architectures. Here, we show the performance comparison of AdamW and SGD on different models. All the vision models are trained on ImageNet. Language models are trained on different English corpus. We grid-search the learning rates for SGD and Adam under the same budget and report the best result for each optimizer. See Appendix D.1 for more implementation details. More results for SGD under careful tuning. For ViT-base, GPT2-nano, and BERT, we further present the performance of SGD under learning rate grid search. For ViT-base training on ImageNet, we report the results after 30 epochs (or equivalently, about 30k iterations). We cannot afford further training ViT-base due to the limited hardware resources (a complete run of 90 epochs would take > 2 weeks for each curve). As shown in Figure 11 , SGD consistently performs worse than Adam on ViT-base, GPT2, and BERT. The best results for SGD are picked out and presented in Figure 10 . (c) BERT Figure 11 : Performance of SGD under careful tuning. On ViT-base, GPT2-nano, and BERT, we carefully tune the learning rate of SGD and show all the results here. For all these Transformer tasks, is still significantly worse than AdamW even after careful tuning.Note that we are not the first ones to report that "SGD performs worse than Adam on ViT". An influential work [92] also reports that SGD is worse than Adam on vanilla ViT. The authors report that "SGD yields significantly worse results than AdamW (on ViT)", and "ViT often fails to converge with SGD " (their Figure 3 ). These results align with our findings in Figure 11 .Detailed training curves of Figure 5 . In Figure 12 , we present the detailed training curves for the man-made MLP in Figure 5 . We find that SGD performs worse as heterogeneity grows, while Adam still performs well. The evolution of Hessian heterogeneity along training. For ViT-base, we further investigate the evolution of block heterogeneity of Hessian along the training. As shown in Figure 13 , we find that heterogeneity attenuates along the training. We further take the checkpoint of ViT-base at 50% training step and switch AdamW to SGD, we observe that now SGD performs better than training from scratch as in Figure 10 (a). SGD performs better here because there is less heterogeneity when initializing in the middle of training. Simplifed SLQ for calculating JS 0 in Section 3.4. We note that JS 0 in Table 1 is rather expensive to compute due to the computational overhead of SLQ: it requires comparable time to one training run. Fortunately, we find the original SLQ is redundant for measuring hessian heterogeneity. We propose the following simple tweaks to significantly reduce the computation time, while still effectively detecting the Hessian heterogeneity. We call it simplified SLQ.• Change the hyperparemters of SLQ, including:-We change num v = 10 to num v = 1. In SLQ, num v decides the number of random Gaussian vectors to approximate the expected quadrature. It is reasonable to reduce num v because in high dimensional space, random vectors tend to concentrate around their mean, so one random sample can already be informative enough. -We change the Lanzcos step m = 100 to m = 10. The reduction on Lanzcos step will have a coarse estimation on the middle eigenvalue, but won't affect much the heterogeneity, which is more dependent on the extreme eigenvalues. • Randomly sample a subset of blocks and reduce batch size for estimating the spectrum. We uniformly sample 50% blocks and choose batch size = 32 (previously batch size = 1024).We report the result and runtime in 3. As a result, the simplified SLQ can obtain the same message as the original SLQ: JS 0 of ResNet is about 100x smaller than that of BERT. Further, the simplified SLQ is highly efficient to compute. With this simplified SLQ, we believe our method can efficiently scale to larger models. The result is tested on a single V100. Does our theory imply that Adam under homogeneity is slower than Adam under heterogeneity? 5 During the review process, we find that readers might conclude that "Theorem 1 implies Adam under homogeneity has worse complexity than Adam under heterogeneity". We would like to clarify that this conclusion is not correct, and there is no conclusion on "whether Adam under homogeneity is faster or slower than Adam under heterogeneity ". We explain as follows.Our theoretical result states that Adam has complexity O (max l κ l ). If our result implies the above conclusion, one needs the following argument: when changing heterogeneity to homogeneity, max l κ l increases, and thus Adam is slower. However, "changing heterogeneity to homogeneity" does not necessarily mean "max l κ l increases". Actually, max l κ l can change in an arbitrary way (can increase, decrease, or keep the same) when changing the heterogeneity. We provide three examples below.We will use Adam (homo) to denote the convergence rate of Adam on homogeneous Hessian, similarly for Adam (hetero).Example 1: Adam (homo) is same as Adam (hetero).• Case 1-1 (homogeneous): eigenvalues are {1,2}, {1,2} • Case 1-2 (heterogeneous): eigenvalues are {1,2}, {11,12} Since max l κ l are the same for both Case 1-1 and 1-2, Adam (homo) is the same as Adam (hetero).Example 2: Adam (homo) is faster than Adam (hetero).• Case 2-1 (homogeneous): eigenvalues are {1,1.5}, {1,1.5} • Case 2-2 (heterogeneous): eigenvalues are {1,2}, {11,12} Since Case 2-1 has smaller max l κ l than Case 2-2, Adam (homo) is faster than Adam (hetero).Example 3: Adam (homo) is slower than Adam (hetero).• Case 3-1 (homogeneous): eigenvalues are {1,12}, {1,12} • Case 3-2 (heterogeneous): eigenvalues are {1,2}, {11,12} Since Case 3-1 has larger max l κ l than Case 3-2, Adam (homo) is slower than Adam (hetero).To sum up, there is no conclusion on "whether Adam under homogeneity is faster or slower than Adam under heterogeneity ". Either case can happen.One possible source of confusion may come from the numerical examples (Case 3 and 4 in Section Section 4.1). If comparing two figures, Adam (homo) in Case 3 is slower than Adam (hetero) in Case 4. But as argued above, this is just one example, and it does not show Adam (homo) is always slower than Adam (hetero).Here we provide a detailed description of the optimizers mentioned in the full script. We consider the minimizing L(w) ≡ 1 n n i=1 L i (w), where n is the number of minibatches, L i (w) is the loss of i-th minibatch and w ∈ R d is the neural network parameters. We denote the gradient of the training loss w.r.t. neural network parameters as ∇L(w) ∈ R d . We use ∇L i (w) ∈ R d to denote the i-th minibatch counterparts. We use w t to denote the variable at the t-th step. In Algorithm 2 and 3, •, division and square-root are elementwise operations. In the line 7 and 8 of Algorithm 2, (β 1 ) t and (β 2 ) t indicates the t-th power of β 1 , β 2 . In the PyTorch default setting, (β 1 , β 2 , ϵ) = (0.9, 0.999, 1e-8) for Adam and β 1 = 0.9 for SGD.1: Initialize w 0 and choose 0 ≤ β 1 < 1 and η 0 > 0 2: for t = 1 → ∞ do m t = β 1 m t + ∇L τ t (x t ) 5: x t+1 = x t -η t m t 6: end for Algorithm 2 AdamW 1: Initialize x 0 , m 0 = v 0 = 0, 0 ≤ β 1 < 1, 0 ≤ β 2 < 1, ϵ > 0, η 0 > 0, and weight decay coefficient λ 2: for t = 1 → ∞ do 3:Uniformly sample τ t from the index set {1, 2, • • • , n} 4:w t+1 = w t -η t λw t 5: m t = β 1 m t + (1 -β 1 )∇L τ t (w t ) 6: v t = β 2 v t + (1 -β 2 )∇L τ t (w t ) • ∇L τ t (w t ) 7: mt = m t 1-(β1) t 8: vt = v t 1-(β2) t 9: w t+1 = w t+1 -η t mt √ vt +ϵ10: end for Algorithm 3 Adam with no bias correction1: Initialize x 0 , m 0 = ∇L τ t (w 0 ), v 0 = ∇L τ t (w 0 ) • ∇L τ t (w 0 ), 0 ≤ β 1 < 1, 0 ≤ β 2 < 1, ϵ > 0, η 0 > 0 2: for t = 1 → ∞ do 3: Uniformly sample τ t from the index set {1, 2, • • • , n} 4: m t = β 1 m t + (1 -β 1 )∇L τ t (w t ) 5: v t = β 2 v t + (1 -β 2 )∇L τ t (w t ) • ∇L τ t (w t ) 6: w t+1 = w t+1 -η t m t √ v t +ϵ7: end for C.2 Preliminaries on the Stochastic Lanczos Quadrature Method Additional notations. Given a real symmetric matrix H ∈ R d×d , we denote tr(H) as its trace and Q T ΛQ as its spectral decomposition, where Q = [q 1 , . . . , q d ] , Λ = diag (λ 1 , . . . , λ d ) andλ 1 ≥ λ 2 • • • ≥ λ d .We denote the condition number of H as κ = λ 1 /λ d . We define matrix function asf (H) := Q T f (Λ)Q, where f (Λ) = diag (f (λ 1 ) , . . . f (λ d )) ∈ R d×d .We use N to denote the set of positive integers. We use ∥ • ∥ 2 to denote the Euclidean norm.Approximation of the Hessian spectrum can be formulated as a trace estimation problem, as introduced in [53, 82] . First, the spectrum (eigenvalue density) of Hessian H can written as:ϕ(t) = 1 d d i=1 δ (t -λ i ), where λ i are the eigenvalues of H and δ is the Dirac δ-function. Then, we replace the delta functions by a Gaussian blurring function:ϕ(t) ≈ g(t) := 1 d d i=1 f (λ i ), where f (λ) := 1 σ √ 2π exp -(t-λ) 2 2σ 2. By definition of matrix function, it is easy to see thatg(t) = 1 d tr(f (H)).As such, spectrum approximation could be formulated as a trace estimation problem, i.e., estimating 1 d tr(f (H)), where H ∈ R d×d is a real symmetric matrix. Trace estimation problems could be solved efficiently by the Stochastic Lanczos Quadrature Method (SLQ) [35] . For the ease of readers, we re-organize and summarize the existing literature ( [35, 82, 32] ) and provide a detailed description of SLQ in our context. SLQ consists of the following steps.Step 1. We Approximate the trace of matrix function as1 d tr(f (H)) = E(v T f (H)v) ≈ 1 nv nv i v T i f (H)v i, where v = u/∥u∥ 2 and u is a Rademacher random vector (each entry of u independently takes ±1 with probability 1/2). This step is called Huchinson's estimation [42] .Note that we can also replace the Rademacher random vector u by a unit Gaussian vector (i.e., u ∼ N (0, I d×d )) and the unbiasedness still holds [4] . In our implementation, we sample u ∼ N (0, I d×d ) because there is an efficient built-in PyTorch function for generating Gaussian vectors.SLQ estimates v T i f (H)v i for i ∈ [n v ]and then take the average. To understand SLQ, we only need to understand how it estimates each individual quadratic form. To simplify the notation regarding i, from now on, we will discuss how to estimate v T f (H)v, where v = u/∥u∥ 2 and u is a unit Gaussian vector.Step 2-1. We rewrite v T f (H)v as a Riemann-Stieltjes integral [34] :EQUATIONwhere µ is a measure on (R, B) defined as follows (µ(λ) denotes the measure of set {x; x ≤ λ}):EQUATIONStep 2-2. Unfortunately, this integral is difficult to compute. This is because the measure µ are related to the eigen-pairs of H, which are unknown. It seems unclear how to directly integrate over an unknown measure. As such, we further approximate this integral by a computationally friendly quantity, such as:EQUATIONWe hope to design {(c j , x j )} m j=1 with a reasonable number of m such that the estimation error is small. Fortunately, the Gaussian Quadrature method provides a generic design principle of {(c j , x j )} m j=1 [34, 29] . It is proved that: when f (λ) is not "too complicated" (e.g. f (λ) is a polynomial), then there exists {(c j , x j )} m j=1 which gives a high quality estimation of integral (8) . The required number of m is related to "how complicated the f (λ) is". Such {(c j , x j )} m j=1 are called the Gaussian Quadrature rules. c j and x j are called the "weights" and the "nodes" of the Gaussian Quadrature rules. A representative theorem is as follows: when f (λ) is a polynomial with degree < 2m, then the Gaussian Quadrature rules give the exact approximation of integral (8). Theorem 2. [Rewrited based on [89] ] Suppose we have a sequence of orthogonal polynomials {p k (x)} m k=1 w.r.t. measure µ, that is:λ1 λ d p n (x)p m (x)dµ(x) = δ m,n, where δ m,n = 1 if m = n and δ m,n = 0, otherwise. Assume f (x) is a polynomial with degree < 2m, then there exists {(c j , x j )} m j=1 s.t. Theorem 2 shows the existence of good {(c j , x j )} m j=1 and their general form. In fact, it is also shown that Gaussian Quadrature is optimal: no other{(c j , x j )} m j=1 can achieve zero approximation error for higher degree polynomials f (λ) [34] . However, it is often difficult to find these quadrature rules [36] . There are at least three questions in sequel:• 1) how to find the orthogonal polynomials {p k (x)} m k=1 w.r.t. an unknown measure µ?• 2) how to efficiently find the roots of p m (x), which gives the nodes x j ?• 3) how to efficiently calculate the weightsc j = λ1 λ d j̸ =i x-xi xj -xi dµ?We first answer question 2) and 3) and leave question 1) for later discussion.Now suppose that we have found the orthogonal polynomials {p k (x)} m k=1 w.r.t. µ. Recall that any orthogonal polynomial has the following "three-term" recursion [34] :p k+1 (x) = (x -α k+1 ) p k (x) -β k p k-1 (x), k = 0, 1, . . . , where p -1 (x) ≡ 0, p 0 (x) ≡ 1, α k+1 = ⟨xp k ,p k ⟩ ⟨p k ,p k ⟩ and β k = ⟨p k ,p k ⟩ ⟨p k-1 ,p k-1 ⟩ . Define P m (x) = (p 0 (x), p 1 (x), . . . p m-1 (x))T ∈ R m , we can rewrite the recursion formula in matrix form (given x):xP m = J m P m + β m p m (x)e m, where e m is the last column of identity matrix I m,m and J m is called Jacobi matrix of order m:J m =      α 1 √ β 1 √ β 1 α 2 √ β 2 √ β 2 α 3 √ β 3 . . . . . . . . .      ∈ R m×mIt turns out that J m can help us find the Gaussian Quadrature rules {(c j , x j )} m j=1 and thus provide answers for question 2) and 3). This is shown in the following theorem. Theorem 3. [34] For the Gaussian Quadrature, {x j } m j=1 are the eigenvalues of J m and {c j } m j=1 are the squares of the first elements of the normalized eigenvectors of J m .The proof of Theorem 3 is based on Christoffel-Darboux relation [11] . Now, the remaining question is: how to find the Jacobian matrix J m of a sequence of orthogonal polynomials w.r.t. an unknown measure µ? Note that we no longer need to answer question 1) if J m is found, since J m is sufficient for us to find the Gaussian quadrature rules. However, it seems impossible to find J m if no information of µ is provided. The good news is: when the µ is specified as in (9) , there exists an efficient way to find J m .Step 3. When µ is specified as in (9) , J m can be exactly found in m steps using the Lanczos algorithm [47] , as shown in Algorithm 4. This method takes a real symmetric matrix as input and returns a tridiagonal matrix. It was originally proposed to solve eigenvalue problems. Later, researchers found a deep connection between the Lanczos algorithm and orthogonal polynomials, which further connects this method to the Gaussian quadrature. The method (of finding the Gaussian quadrature by the Lanczos algorithm) is called the Lanczos quadrature [35, 6, 34] . An extremely elegant but highly nontrivial result is as follows: Theorem 4.[34] Given a real symmetric matrix H ∈ R d×d and an arbitrary vector v ∈ R d with unit Euclidean norm, we define the measure µ as in (9) based on this H and v. Then m steps of the Lanzcos algorithm return the Jacobian matrix J m of orthogonal polynomials w.r.t. to µ.After J m is found by the Lanczos algorithm, we perform spectral decomposition of J m ∈ R m×m to get its eigen-pairs. Using Theorem 3, we successfully get the Gaussian quadrature rules and thus we can approximate the quadratic form v T f (H)v. By averaging over different random vectors v we can then approximate 1 d tr(f (H)). This concludes the derivation of SLQ for the trace estimation problem.The full procedure of SLQ is shown in Algorithm 5. We note that SLQ is efficient in theory. Ubaru et al. [82] show that SLQ converges faster than any other polynomial expansion method for spectrum estimation (e.g., Chebyshev methods used in [2] ). See [82, Theorem 4.1] for a formal statement.We remark that there are at least four versions of the Lanczos algorithm in Step 3. Here, we adopt the version in Algorithm 4 since it is known to be the most numerically stable version [20, 73, 89] . Throughout this work, we choose f (•) as the Gaussian blurring function f (λ) :=1 σ √ 2π exp -(t-λ) 2 2σ 2for spectrum approximation. We plot the spectrum by sweeping t from the minimal node to the maximal node in Gaussian Quadrature rules.1: Input a matrix-vector product Hv 1 ∈ R d , where H is a real symmetric matrix and v 1 is an arbitrary vector with Euclidean norm 1. Choose m ∈ N 2: Initialization:Let w ′ 1 = Hv 1 , α 1 = (w ′ 1 ) T v 1 , w 1 = w ′ 1 -α 1 v 1 3: for j = 2 → m do 4:Let β j = ∥w j-1 ∥ 2 (also Euclidean norm) 5:If β j ̸ = 0, then let v j = w j-1 /β j , else pick as v j an arbitrary vector with Euclidean norm 1 that orthogonal to all of v 1 . . , v j-1Let w ′ j = Av j 7:Let α j = (w ′ j ) T v j 8:Let w j = w ′ j -α j v j -β j v j-1 9: end for 10: Let V be the matrix with columns v 1 , . . . , v m Implementation and Running Time Analysis. We provide a simple PyTorch implementation of SLQ. The only query SLQ makes to the neural network is the Hessian vector product, which is attained using the auto-differentiation framework [70] . To assure the accuracy of the Lanczos algorithm, we remove all the randomness in the forward and backward passes, including: data shuffling order, data augmentation, and dropout, etc.. Since Flash Attention [22] does not support the calculation of Hessian-vector product, we implement all attention blocks in the naive way. For the calculation of the blockwise Hessian spectrum ∇ 2 L(w l ), we sample u l ∼ N (0, I d l ×d l ) and set v l = u l /∥u l ∥ 2 ∈ R d l . Then we run Algorithm 5 by taking ∇ 2 L(w l ) and v l as inputs. We choose the hyperparameters as m = 100 and n v = 10 in all experiments. σ is tuned based on visual effects. These hyperparameters are reported to reach highly accurate estimation with error < 10 -14 [32] .EQUATIONWe now briefly discuss the computational cost of SLQ. The major computational expense of SLQ is the repeated Hessian-vector product operations in Lanczos algorithm in Step 3. Recall ∇ 2 L(w)d = 1 n n i=1 ∇ 2 L i (w)d, so each Hessian-vector product operation requires (i) calculating ∇ 2 L i (w)d; (ii) repeating (i) on all data. We point out that (i) can be computed efficiently and precisely with just two backpropagation passes [70] . The major computational bottleneck lies in (ii) due to the large n. Our largest-scale experiment for Hesian spectrum is GPT2 (125M) on Openwebtext, where the number of tokens n = 9 Billon. To calculate ∇ 2 L(w)d on all these 9B tokens, it requires about 9 GPU days on eight A100-80GB GPUs. Since SLQ requires at least 1,000 times query of ∇ 2 L(w)d, a complete run of SLQ would take at least 9,000 days on eight A100-80GB GPUs, which is unaffordable. In this work, we use the largest possible batch size (with gradient accumulation tricks) to approximate ∇ 2 L(w) under the constraints of GPU bandwidth and time limit. More detailed setup of SLQ are shown as follows.• ResNet18 (18M) and VGG16 (138M) on ImageNet. We use the code base of PyTorch Examples 6 . We use batch size = 1024. For the calculation of the blockwise Hessian spectra, we apply SLQ to all parameter blocks except for the BatchNorm layers. In total, it takes about 3 days on one V100 GPU to estimate all the blockwise Hessian spectra and the full Hessian spectrum.• ViT-base (86M) on ImageNet. We use the code base of PyTorch Image Models 7 . We use batch size = 1024. Due to the large number of parameters, we are not able to calculate the blockwise Hessian spectra for all parameter blocks. Instead, we apply SLQ to: the embedding layer; the output layer; the 1-st, 6-th, 12-th attention blocks; and the 1-st, 6-th, 12-th MLP blocks (note that the 12-th attention and MLP blocks are the final ones). In total, it takes about 3 days on one V100 GPU to estimate all the blockwise Hessian spectra and the full Hessian spectrum.• BERT(40M) on Cornell Movie-Dialogs Corpus. We use the code base from the blog 8 . We use batch size = 327, 680 tokens. For the calculation of the blockwise Hessian spectra, we apply SLQ to all parameter blocks except for the LayerNorm layers. In total, it takes about 12 hours on one V100 GPU to estimate all the blockwise Hessian spectra and the full Hessian spectrum.• GPT2-nano (11M) on Shakespeare. We use the code base of NanoGPT9 . We use batch size = 163, 840 tokens. For the calculation of the blockwise Hessian spectra, we apply SLQ to all parameter blocks with even indices, except for the LayerNorm layers. In total, it takes about 12 hours on one V100 GPU to estimate all the blockwise Hessian spectra and the full Hessian spectrum.• GPT2 (125M) on Openwebtext 10 . We use the code base of NanoGPT. We use batch size = 245, 760 tokens. Due to the large number of parameters, we are not able to calculate the blockwise Hessian spectra for all parameter blocks. Instead, we apply SLQ to: the embedding layer; the output layer; the 1-st, 4-th, 8-th, 12-th attention blocks; and the 1-st, 4-th, 8-th, 12-th MLP blocks (note that the 12-th attention and MLP blocks are the final ones). In total, it takes about 7 days on one A100 GPU to estimate all the blockwise Hessian spectra and the full Hessian spectrum.Training configuration. In all cases, we train all the models under the default configurations in the above codebase. We grid-search the learning rates for SGD and Adam under the same budget and report the best result for each optimizer. We use the cosine-decay learning rate schedule for vision tasks. For SFT task, we use nanoGPT codebase. We first pre-train GPT2 on OpenwebText for 25B tokens and then fine-tune it on a subset of Alpaca Eval11 .On a small GPT model with 75k parameters, we compare (1) the true Hessian spectrum and (2) the estimated Hessian spectrum curve by SLQ method. As shown in Figure 16 , we find that the SLQ method can produce accurate estimation. The experiments are conducted on a small GPT model with 75k parameters. We find that the SLQ method can produce accurate estimation.We employ a synthetic dataset designed for binary with 100 data points generated through the process outlined below. Our model is a 1-hidden-layer neural network, featuring an input size of 64 and a layer width of 8, utilizing the hyperbolic tangent (Tanh) as the activation function. We train this model over 1000 iterations using the Adam optimizer with a learning rate set to 1 × 10 -4 , achieving the classification accuracy of 100%.1 def generate_data ( n_samples_per_class , n_classes , input_dim ) : We train a 4-layer MLP on MNIST. We use batch size = 128 and width = 300, 128, and 64 for the hidden layers. We use ReLU activation. We change the degree of heterogeneity by scaling the output of each layer with constant c ∈ N. We scale c from 1 to 15. For each c, we train SGD and Adam with default hyperparameters by grid-searching the learning rate from 1e-4 to 1e-1 and report the best test accuracy after 1 epoch.w t+1 = w t -η(D 0 Adam ) -1 Hw t ,where D 0 Adam = diag(∇L(w 0 ) • ∇L(w 0 ))1 2 = diag(|Hw 0 |). We denote d t = η(D 0 Adam ) -1Hw t and thus we have w t = 1 η H -1 D 0 Adam d t and w t+1 = w t -d t . These relations also hold for each block by changing the notation to H l w t l , D 0 Adam , and d t l , etc.. Following the framework in [80] , we try to bound the error yet to be optimized (a.k.a., cost-to-go) and the per-step improvement, respectively. The ratio of these two terms characterizes the rate of convergence. We now express both terms using d t l . For the cost-to-go term for the l-th block, we haveEQUATIONFor the per-step improvement, we haveEQUATIONTo proceed, we denote Ĥ = (D 0 Adam ) -1 H and we denote its eigenvalues as λ1EQUATIONEQUATIONEQUATIONwhere ( * ) is due to: by Assumption 1, D 0Adam,l ≼ C l,2 λ l,1 I, 2 η D 0 Adam,l -H l ≽ 2 C l,1 C 1l, λ l,1 -λ l,1 I ≽ λ l,1 I, where ≼ and ≽ are matrix inequalities. By rearranging both sides of (20), we have[L(w t+1 )] l -[L * ] l ≤   1 - 1 max l∈[L] C 2 l,2 min l∈[L] C 2 l,1 κ l   ([L(w t )] l -[L * ] l ).Summing up both sides over l ∈ [L] and we conclude the proof.L(w t+1 ) -L * = L l=1 [L(w t+1 )] l -[L * ] l ≤ L l=1     1 - 1 max l∈[L] C 2 l,2 min l∈[L] C 2 l,1 κ l     [L(w t )] l -[L * ] l ≤ max l∈[L]     1 - 1 max l∈[L] C 2 l,2 min l∈[L] C 2 l,1 κ l     L l=1 [L(w t )] l -[L * ] l = max l∈[L]     1 - 1 max l∈[L] C 2 l,2 min l∈[L] C 2 l,1 κ l     L(w t ) -L * .• The answer NA means that the paper does not include theoretical results.• All the theorems, formulas, and proofs in the paper should be numbered and cross-referenced.• All assumptions should be clearly stated or referenced in the statement of any theorems.• The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide a short proof sketch to provide intuition. • Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material. • Theorems and Lemmas that the proof relies upon should be properly referenced.https://github.com/karpathy/nanoGPT/For all NLP tasks, clipping is performed immediately after backpropagation. So in Figure10, SGD in NLP tasks essentially refers to clipped SGD.We would like to thank the anonymous Reviewer pTmy for raising this insightful question.https://github.com/pytorch/examples/blob/main/imagenet/main.pyhttps://github.com/huggingface/pytorch-image-modelshttps://medium.com/data-and-beyond/complete-guide-to-building-bert-model-from-sratch-3e6562228891https://github.com/karpathy/nanoGPT/https://huggingface.co/datasets/Skylion007/openwebtexthttps://huggingface.co/datasets/tatsu-lab/alpaca_eval 


Decision: Great paper!  Review scores: 6 6 7 5

The paper explores and partially answers the question why SGD is worse than Adam when training transformer models.  The reviews did identify potential weaknesses which the rebuttal of the authors did successfully clear out.  I didn't find the weaknesses pointed out by review with the lowest score (the 5, reviewer 5ncB) very convincing.  Also the review got a detailed rebuttal  as well, but that wasn't acknowledged by the reviewer.

So overall this is a really nice paper that should be accepted!

Reviews: review: paper_summary: paper_summary: In this work the authors assert that the Adam optimizer works well on Transformers while Stochastic Gradient Descent (SGD) does not, and they attempt to explain this phenomenon by inspecting the spectrum of Transformers (i.e., the eigenvalues of the model's Hessian matrix) and other models, such as convolutional networks, where SGD is competitive with Adam.  They show that the spectrum of Transformers and convolutional networks are similar, providing little insight.  The main innovation of the authors is to investigate the spectrum of individual components/layers of these networks - the so-called block spectrum - and the main contribution of the work is to show that the block spectrum is empirically correlated with the ineffectiveness of SGD relative to Adam.
strength_weakness: strength_weakness: 1) The premise of this paper is that SGD performs worse for attention-based models, and it is unclear to me if this is true.  I say this for two reasons:
a) The authors cite [45,56] on Line 16 after making this claim, presumably to support the claim.  However, these are quite old publications and neither of these papers specifically make this claim.  Are there other publications that make these claims? 
b) The authors also provide their own empirical results (e.g., Fig. 3) to support this claim, however, these results seem highly insufficient to me to support this claim.  How did the authors choose/optimize the learning rate for SGD, and/or the learning rate schedule? 

If SGD does not generally perform worse than attention models on Transformers, then it seems to me that the work has little scientific value, since the differences in the block spectrum are just inconsequential differences, or at least that their implications are different than suggested by the authors.  e.g., perhaps the authors could argue that the heterogeneous block spectra implies that SGD needs a lot more tuning to work well, for example.    I'd ask the authors to please address this point, and I will consider raising my rating.       

2) Novelty of using block spectrum (potentially).  To me this is the main value of this work.  I'm not as familiar with this topic, and it is unclear to me how non-obvious the use of a block spectrum would be for analysis, or how surprising the results of using this approach are: perhaps these findings would be somewhat obvious to researchers familiar with this topic?    I will defer to other reviewers for this assessment.
questions: questions: See "Weaknesses" for my questions.
limitations: limitations: yes.
paper_summary: paper_summary: The paper investigates why SGD performs worse than Adam in Transformers from the lens of Hessian. They first find that Transformers are "heterogeneous", that is, the Hessian spectrum across parameter blocks varies dramatically. Then they conduct various tasks on Transformers, CNNs, MLPs, and quadratic problems, to verify that block heterogeneity hampers SGD. Finally, they derive some initial theoretical analysis to indicate that SGD fails because it applies one single learning rate for all blocks, which cannot handle the heterogeneity among blocks.
strength_weakness: strength_weakness: 1. The paper demonstrates that for different models when there the block heterogeneous at initialization increases, SGD becomes much worse than Adam. However, these comparisons are between different models. It is natural to ask for the same Transformers model, when the initialization changes to induce different block heterogenous levels, how would the performance of SGD compared with Adam change?

2. The theoretical results of the convergence of Adam for the quadratic models show that homogeneous spectra have worse complexity than heterogeneous spectra, is this the truth in practice?
questions: questions: See weakness
limitations: limitations: The authors have addressed the limitations.
paper_summary: paper_summary: This paper investigates why Adam outperforms SGD in Transformers by examining Hessian estimations. While the overall Hessian spectrum appears similar in both Transformers and other neural networks, the block-wise Hessian spectrum is heterogeneous across blocks in Transformers and homogeneous in other neural networks. The authors empirically confirm that this heterogeneity hampers SGD's performance through experiments involving Transformers, CNNs, MLPs, and quadratic problems. They attribute Adam's advantage to its coordinate-wise learning rate and provide initial theoretical analysis in a simplified setting.
strength_weakness: strength_weakness: - The experiments support the claim that Adam outperforms SGD when Hessian block-wise heterogeneity structure is present. However, it is unclear whether this correlation implies causation beyond intuitive understanding. In general, the conceptual contribution is not very strong.
- The definition of "block" also seems arbitrarily determined. For example, Fig. 3 shows that all convolution layers have a similar spectrum, while the spectrum differs between Query, Value, and MLP blocks in Transformers. Given that one set is the same type of "block" (conv layer) and the other is not, this does not seem surprising. Since how the block is defined entirely determines Hessian heterogeneity versus homogeneity, this observation might be overfitting the transformer architecture and could be difficult to generalize to non-mainstream architectures as claimed. 
- The case study on quadratics helps understand and attempt initial theoretical analysis, but it only partially represents behaviours in larger networks. The noise in SGD does not play a significant role here, and Adam with $\beta_2 = 0.99$ performs very differently than in larger networks.
questions: questions: -  Including a more detailed experimental setting will help with reproducibility. The hyperparameters for experiments such as learning rate are not included. Since SGD is sensitive to hyperparameters, it's unclear whether the gap is due to the claimed reason or if hyperparams are insufficiently tuned. For example, the training curve of SGD in Figure 9(a) in ViT-ImageNet is much lower than Adam and that is not the case in [Figure 12, Kunstner et.al. Heavy-Tailed Class Imbalance and Why Adam Outperforms Gradient Descent on Language Models]. Can the author comment on this?
- Figure 1 shows the full spectrum across different time points to illustrate its evolution during training, yet all other plots in the paper related to the block-wise spectrum are presented at initialization. Is there a reason why the evolution of the block-wise spectrum is not shown?
- Are there any ablation studies on how well the Hessian spectrum is estimated through the SQL method, perhaps on reasonably small networks?
- Typo in Figure 7 y-axis label
limitations: limitations: Limitations are well-addressed
paper_summary: paper_summary: This paper explores the performance gap between SGD and Adam when training transformers. The authors analyze the eigenspectrum of the Hessian in different neural network architectures and attribute the failure of SGD to the different Hessian spectra in transformers compared to CNNs and MLPs. They empirically show that while the full Hessian spectrum is similar at initialization across architectures, transformers exhibit block heterogeneity, meaning different parameter blocks (e.g., key/query layer versus MLP layer) have distinct spectra. Conversely, other architectures such as CNNs and MLPs are block homogeneous. By artificially inducing block heterogeneity in MLPs, they demonstrate through numerical experiments that SGD's performance declines as the block spectrum variation increases, while Adam's performance remains stable. They attribute Adam's success in block heterogeneous cases to its ability to assign different learning rates to different parameters. The authors also propose using the Jensen-Shannon distance of Hessian blocks as a quantitive measure of the performance gap. They also provide a preliminary theoretical analysis comparing the convergence rates of SGD and Adam on a quadratic function with a block-form Hessian, highlighting Adam's dependence on the fine-grained condition number of individual Hessian blocks.
strength_weakness: strength_weakness: Quantifying the performance gap between SGD and Adam using the average JS distance between block-wise Hessian spectra is an interesting idea. However, based on the runtime reported in the appendix, the Hessian approximation itself seems computationally expensive, which can raise concerns about how practical it is for large models, especially since the experiments in this paper are only on small models.

Additionally, the main theoretical analysis is conducted in a pretty simplified setup where the momentum part of Adam is fully ignored ($\beta_1=0$ in Algorithm 3).
questions: questions: 1. Can you comment on the computational complexity of calculating the JS distance and the Hessian approximation? Specifically, can you compare the runtime of computing this quantitative measure to the training time of the models in your paper? For significantly larger models, do you expect this approach to scale efficiently and be more practical than training the model?

2. Is the architecture the only factor affecting the Hessian structure? I am curious if the training distribution, particularly label imbalance, also impacts the Hessian structure, since in some previous works previous works, such as [46], the performance gap has been attributed to the heavy-tailed distribution of labels in language data.
limitations: limitations: Yes

Comments: title: Response to authors
TLDR: Reviewers please do acknowledge the rebuttals and react to them.
comment: Thank you for addressing my concerns; I will raise my score accordingly.
Thanks for the authors' responses. The authors carefully address my questions. I thank the authors for pointing out that either case can happen for Adam under homogeneity and heterogeneity. The confusion is indeed caused by Case 3 and 4 in Section 3.1, where the diagonal elements are the same, but in different order. Maybe such reordering of the same elements has some correlation with the algorithm's complexity. Overall, I think this work is interesting and has potential for the community, thus I would like to update my score to 7.
Dear reviewers,

thanks for your reviews.  Please do look at the rebuttals of the author and give the authors some feedback whether they could address your concerns.  This is really important for the authors.

Best regards Your AC.
Thanks for your response. I think the results will interest the community. I'll keep my score as is.