AdaFisher: Adaptive Second Order Optimization via Fisher Information

## Abstract

Abstract First-order optimization methods are currently the mainstream in training deep neural networks (DNNs). Optimizers like Adam incorporate limited curvature information by employing the diagonal matrix preconditioning of the stochastic gradient during the training. Despite their widespread, second-order optimization algorithms exhibit superior convergence properties compared to their first-order counterparts e.g. Adam and SGD. However, their practicality in training DNNs are still limited due to increased per-iteration computations and suboptimal accuracy compared to the first order methods. We present AdaFisher–an adaptive second-order optimizer that leverages a block-diagonal approximation to the Fisher information matrix for adaptive gradient preconditioning. AdaFisher aims to bridge the gap between enhanced convergence capabilities and computational efficiency in second-order optimization framework for training DNNs. Despite the slow pace of second-order optimizers, we showcase that AdaFisher can be reliably adopted for image classification, language modelling and stand out for its stability and robustness in hyperparameter tuning. We demonstrate that AdaFisher outperforms the SOTA optimizers in terms of both accuracy and convergence speed. Code is available from https://github.com/AtlasAnalyticsLab/AdaFisher .

## 1 Introduction

Deep Neural network (DNN) optimization often struggles with the challenge of generalizing across varied architectures and complex data distributions. Current methods such as Adam optimizer (Kingma & Ba, ) and its variants (AdamP (Heo et al., ), AdaInject (Dubey et al., ), AdaBelief (Zhuang et al., ) and YOGI Zaheer et al. ()) require extensive hyperparameter tuning and often fail to generalize efficiently. In response, DNN training typically minimizes an empirical loss function $\mathcal{L}(\theta)$, updating parameters $\theta$ using the expression $\theta_{t+1}=\theta_{t}-\alpha G^{-1}_{t}\nabla\mathcal{L}(\theta_{t})$ at time step $t$, where $G_{t}$ represents curvature information, i.e. Hessian or Fisher Information Matrix (FIM) (Amari & Nagaoka, ). The Hessian matrix interfaces with the deterministic Newton method (Martens, ), whereas the FIM harmonizes with the Natural Gradient Descent (NGD) approach (Amari & Nagaoka, ) as a statistical method. These curvature information crucially optimize the gradient’s preconditioning by accurately rescaling and orienting it. This adjustment significantly accelerates convergence by ensuring more direct progress towards minima, thus enhancing training efficiency and reducing the number of required iterations.

While first-order methods such as SGD (Kiefer & Wolfowitz, ) simplify $G_{t}$ by treating it as the identity matrix, second-order methods employ curvature matrices to enhance the optimization process. Although these matrices accelerate convergence by effectively navigating saddle points and swiftly moving towards minima (Foret et al., ), they require higher computational resources. In fact, when the number of learnable parameters increases, the curse of dimensionality associated with curvature matrix $G_{t}$ makes the entire process completely intractable for routine deep learning training tasks. Noteworthy approaches, such as Adagrad (Duchi et al., ), Adadelta (Zeiler, ), RMSProp (), and Adam family utilize a simple diagonal approximation of the empirical FIM, which often results in convergence to suboptimal local minima and poor generalization (Wilson et al., ; Luo et al., ). Advanced methods like AdaHessian (Yao et al., ) and Shampoo (Gupta et al., ) improve on this by integrating structured matrices such as the diagonal Hessian or tensor-based preconditioners to enhance optimization. However, these second-order approaches including K-FAC (Martens & Grosse, ; Eschenhagen et al., ) still face challenges of high computational demands, lack generalization and the need for extensive hyperparameter tuning when applied to large models (Ma et al., ).

Figure: Figure 1: Visualization of optimization paths for various optimizers on a loss surface, comparing their convergence efficiency.
Refer to caption: extracted/5936014/images/output.jpg

To address these challenges, we present AdaFisher, an adaptive second-order optimizer, as an innovative solution to address the generalization challenges raised in training DNNs. Substituting the second moment of Adam by a novel diagonal block-Kronecker approximation of the FIM, it strikes a balance between simplicity and generalization by introducing one additional hyperparameter compared to Adam but fewer than K-FAC, AdaHessian or Shampoo. This feature, combined with comparable memory and time requirements than the first-order methods, enhances AdaFisher’s practicality for achieving effective generalization in DNN optimization. As illustrated in Figure 1, AdaFisher not only converges more rapidly but also reaches a superior local minimum by effectively navigating through saddle points compared to its counterparts. Further details regarding the visualization can be found in Appendix C. Our main contributions are as follows: [C1] We empirically showcase the diagonal dominance of Kronecker factors’ energy and provide fresh insights of FIM in optimization;
[C2] We introduce a diagonal block-Kronecker approximation of the FIM applicable to various layers, including normalization layers, enhancing model adaptability;
[C3] We demonstrate AdaFisher’s robustness and stability across diverse settings, proving its effectiveness;
[C4] We showcase AdaFisher’s superior performance against traditional optimizers empirically in image classification and language modeling;
[C5] We develop a new technique that visualizes trajectories across different optimizers for better understanding of model behavior in the loss landscape. Additionally, we introduce an explainable FIM measure from AdaFisher, enabling comparative analysis of optimizer behavior.

## 2 Background

We consider a supervised learning framework with a dataset $\mathbf{D}$ containing $N$ i.i.d samples, $\mathbf{D}:=\{x_{n},y_{n}\}_{n=1}^{N}$ where $x_{n}\in\mathbb{R}^{d}$ and $y_{n}\in\mathbb{R}^{C}$. Let $f_{\theta}:\mathbb{R}^{d}\rightarrow\mathbb{R}^{C}$ be a L-layer neural network parametrized by $\theta$ where $\theta_{i}=concat(W_{i},b_{i})\in\mathbb{R}^{P_{i}}$, and $P_{i}=P_{i}^{out}\times(P_{i}^{in}+1)$. Let $\mathcal{L}:\mathbb{R}^{C}\times\mathbb{R}^{C}\rightarrow\mathbb{R}$ be the loss function defined by negative log likelihood, i.e. $\mathcal{L}(y,f_{\theta}(x)):=-\log p_{\theta}(y|x)$ where $p_{\theta}(y|x)$ is the likelihood of the neural network $f_{\theta}$. The network computes its output $h_{L}=f_{\theta}(x)$ according to: $a_{i}=\theta_{i}\bar{h}_{i-1}$, $h_{i}=\phi_{i}(a_{i})$, $\forall\,i\in\{1,\dots,L\}\,\,|\,\,h_{0}=x_{n}$ where $\bar{h}_{i}=[1,h_{i}^{T}]^{T}\in\mathbb{R}^{P_{i}^{in}+1}$
terminated by $z:=h_{L}\in\mathbb{R}^{P_{L}^{out}}$. For a given input target pair $(x,y)$, the gradient of the loss $\mathcal{L}(y,f_{\theta}(x))$ concerning the weights are computed by the backpropagation algorithm (Lecun, ). For convenience, we adopt the special symbol $s_{i}=\nabla_{a_{i}}\mathcal{L}$ for the pre-activation derivative. Starting from $\nabla_{h_{L}}\mathcal{L}=\partial_{z}\mathcal{L}(y,z=h_{L})$, we perform: $s_{i}:=\nabla_{a_{i}}\mathcal{L}=\nabla_{h_{i}}\mathcal{L}\odot\phi_{i}^{
\prime}(a_{i}),\,\nabla_{\theta_{i}}\mathcal{L}=s_{i}\bar{h}_{i-1}^{T},\,
\nabla_{\bar{h}_{i-1}}\mathcal{L}=\theta_{i}^{T}s_{i}\quad|\,\,\forall i\in\{L
,\dots,1\}$, where $\odot$ denotes the element-wise product. Finally, the gradient $\nabla_{\theta}\mathcal{L}$ is retrieved by: $\nabla_{\theta}\mathcal{L}=[\text{vec}(\nabla_{\theta_{1}}\mathcal{L})^{T},
\text{vec}(\nabla_{\theta_{2}}\mathcal{L})^{T},\dots,\text{vec}(\nabla_{\theta
_{L}}\mathcal{L})^{T}]^{T}$.

Optimization of a DNN can be recast as a problem of finding the parameter set $\theta$ that maximizes the likelihood, or equivalently, minimizes the negative log-likelihood of the observed data. This Maximum Likelihood Estimation approach can be expressed as an unconstrained optimization problem: $\min_{\theta}\,J(\theta)=\sum_{n=1}^{N}\mathcal{L}(y_{n},f_{\theta}(x_{n}))$, where $J(\theta)$ denotes the objective function, corresponding to the negative log-likelihood of the data.
The FIM, utilized in lieu of the Hessian for Newton’s method (Holmgren, ), approximates the curvature of the log-likelihood function (Amari, ). It is defined as:

$$ $\displaystyle F=\sum_{n=1}^{N}\mathbb{E}_{y\sim p(y|f_{\theta}(x_{n}))}\left[ \nabla_{\theta}\log p_{\theta}(y|x_{n})\nabla_{\theta}\log p_{\theta}(y|x_{n}) ^{T}\right]$ $\displaystyle=\mathbb{E}\left[\nabla_{\theta}\mathcal{L}(\nabla_{\theta} \mathcal{L})^{T}\right],$ (1) $$

where $F$ measures the expected information that an observable $y$ conveys about the parameter $\theta$. For brevity, we write $\mathbb{E}$ instead of $\mathbb{E}_{y\sim p(y|f_{\theta}(x_{n}))}$. The K-FAC approach further simplifies FIM calculation using a block-diagonal approximation in DNNs, known as Empirical FIM (EFIM), denoted $\hat{F}$. In Eq. (1), $F$ is construed as a block matrix with dimensions $L\times L$, where each $(i,j)$th block $F_{i,j}$ is articulated by $F_{i,j}=\mathbb{E}[\text{vec}(\nabla_{\theta_{i}}\mathcal{L})\text{vec}(\nabla
_{\theta_{j}}\mathcal{L})^{T}]$. By harnessing the vectorization identity $\text{vec}(uv^{T})=v\otimes u$, we express $\text{vec}(\nabla_{\theta_{i}}\mathcal{L})$ as $\bar{h}_{i-1}\otimes s_{i}$ (Petersen & Pedersen, ), where $\nabla_{\theta_{i}}\mathcal{L}$ is defined as $s_{i}\bar{h}_{i-1}^{T}$. By segmenting the FIM into discrete layer-specific blocks, we can effectuate a systematic factorization of each block

$$ $\displaystyle\hat{F}_{i,j}=\mathbb{E}[\text{vec}(\nabla_{\theta_{i}}\mathcal{L })\text{vec}(\nabla_{\theta_{j}}\mathcal{L})^{T}]=\mathbb{E}[\bar{h}_{i-1}\bar {h}_{j-1}^{T}\otimes s_{i}s_{j}^{T}]\approx\mathbb{E}[\bar{h}_{i-1}^{T}\bar{h} _{j-1}]\otimes\mathbb{E}[s_{i}^{T}s_{j}],$ $$

Figure: Figure 2: Illustration of EFIM computation using K-FAC for a given layer $i$.
Refer to caption: extracted/5936014/images/background_summary.png

where $i,j$ span the layer indices from 1 to $L$. Here, $\mathbb{E}[\bar{h}_{i-1}^{T}\bar{h}_{j-1}]$ and $\mathbb{E}[s_{i}^{T}s_{j}]$ are empirically approximated using batch statistics, simplifying the computation for large-scale DNNs (Tang et al., ). Notably, $\bar{h}_{i-1}\in\mathbb{R}^{M\times(P_{i}^{in}+1)}$ and $s_{i}\in\mathbb{R}^{M\times P_{i}^{out}}$, where $M$ is the size of a batch, rendering $\hat{F}_{i,j}\in\mathbb{R}^{(P_{i}^{in}+1)P_{i}^{out}\times(P_{i}^{in}+1)P_{i}
^{out}}$.
Initially, K-FAC estimates the expectation of the Kronecker product under the presumption that activations and pre-activation derivatives are mutually independent, succinctly represented as the Kronecker product of the individual expectations: $\hat{F}_{i,j}=\mathcal{H}_{i-1,j-1}\otimes\mathcal{S}_{i,j}$, where $\mathcal{H}_{i,j}=\mathbb{E}[\bar{h}_{i}^{T}\bar{h}_{j}]$ and $\mathcal{S}_{i,j}=\mathbb{E}[s_{i}^{T}s_{j}]$, denoting the Kronecker factors. The assumption for the block-diagonal structure posits that weight derivatives across distinct layers are uncorrelated, expressed as: $F\approx\hat{F}=\text{diag}(\hat{F}_{1,1},\ldots,\hat{F}_{L,L})=\text{diag}(
\hat{F}_{1},\ldots,\hat{F}_{L})$. Figure 2 shows EFIM computation via K-FAC.

## 3 Methodology

Our methodology consists of four primary components: (i) Analyzing the Kronecker factors’ structure in Section 3.1 and showcase their diagonal dominance; (ii) Introducing a novel approximation of the FIM that retains only the diagonals of the Kronecker factors, detailed in Section 3.2; (iii) Enhancing the Adam optimizer by incorporating our diagonal FIM approximation as an alternative to the conventional second moment, described in Section 3.3; (iv) Providing a theoretical proof of AdaFisher’s convergence under both convex and non-convex conditions in Section 3.4.

### 3.1 Diagonal Concentration of Kronecker Factors

Figure: Figure 3: Gersgorin disks and eigenvalue perturbations in the $37$th Convolutional Layer of a ResNet-18 at steps 5200 (middle of training) and 9800 (end of training). Left: Gersgorin circles; Right: Eigenvalue spectrum with/without noise.
Refer to caption: extracted/5936014/images/analysis_Conv37_b.png

Inspired by Gersgorin’s Circle Theorem (Horn & Johnson, ), we empirically conclude the diagonal concentration property of the Kronecker factors from the eigenvalue distribution and its perturbation under Gaussian noise. For demonstration, we focus on the eigenvalue spectrum of weight matrices from the $37$th layer of ResNet-18 (He et al., ), after training for 50 epochs on CIFAR-10 (Krizhevsky et al., ). As Figure 3 illustrates, the eigenvalues (denoted as red crosses) predominantly cluster within the Gersgorin discs, which are centered along the matrix’s diagonal elements (denoted as black circles), signifying substantial diagonal dominance. This phenomenon is quantitatively supported by the Gersgorin’s Circle Theorem, which posits that every eigenvalue $\lambda$ of a complex square matrix $\mathcal{A}$ lies within at least one of the Gersgorin discs $D(a_{ii},R_{i})$, where $R_{i}=\sum_{j\neq i}|a_{ij}|$ represents the radius computed as the sum of the absolute values of the off-diagonal entries of the $i$th row. Next, we introduce Gaussian noise $\mathcal{N}(0,\sigma^{2})$, $\sigma=10^{-3}$ to the off-diagonal elements. The perturbed matrix $\hat{\mathcal{M}}$ is then expressed as: $\hat{\mathcal{M}}=\mathcal{A}+\mathcal{E},\quad\text{where }\mathcal{E}=[e_{ij
}]\text{ and }e_{ij}\sim\mathcal{N}(0,\sigma^{2})\text{ for }i\neq j$. This allows us to scrutinize the noise-induced perturbation on eigenvalues, which are pivotal for comprehending the dynamics and stability of the system. This demonstrates that the introduction of noise to the off-diagonal elements induces only minimal perturbations in the eigenvalues, particularly those surpassing the Kaiser criterion, which remain virtually unchanged (Braeken & Van Assen, ). This negligible shift corroborates the robustness of the matrix’s diagonal dominance. An extensive discussion of this analysis is available in Appendix A.1.

### 3.2 Efficient Computation of the FIM

In the realm of optimization, NGD offers a geometrically nuanced adaptation of the classical steepest descent approach, transitioning the focus from parameter space to the model’s distribution space underpinned by the adoption of a Riemannian metric, Amari & Nagaoka (). The formulation of NGD is articulated as

$$ $\displaystyle\triangle\theta_{t}=F_{t}^{-1}\nabla J(\theta_{t}),$ (2) $$

where $F_{t}$ denotes the FIM at time $t$ distinguished from $F_{i}$, the FIM at layer $i$. One of the distinguishing features of NGD within this framework is its reparameterization invariance, a direct consequence of leveraging the model’s distribution properties rather than its parameters. Nevertheless, the direct computation of the FIM poses significant challenges due to its computational demands.

For the efficient approximation of the FIM, we present the following: (1) a methodology for calculating the Kronecker factors for normalization layers, and (2) diagonal approximation of the Kronecker factors. Beyond conventional layers such as convolutional and linear layers that are well established (Grosse & Martens, ; Martens & Grosse, ), the Kronecker factors for BatchNorm (Ioffe & Szegedy, ) and LayerNorm (Ba et al., ) normalization can be derived with Proposition 3.1.

###### Proposition 3.1 .

Consider a neural network layer indexed by $i$, and a mini-batch $\mathbb{B}\subset\mathbf{D}$ of size $M$ ($|\mathbb{B}|=M$). The empirical statistics of the Kronecker factors for the normalization layers can be characterized by

$$ $\displaystyle\mathcal{H}_{i}=\frac{\left(\sum_{\mathbb{B}}\sum_{\mathcal{T}} \bar{h}_{i}\right)^{T}\left(\sum_{\mathbb{B}}\sum_{\mathcal{T}}\bar{h}_{i} \right)}{(M|\mathcal{T}|)^{2}},\,\mathcal{S}_{i}=\frac{\left(\sum_{\mathbb{B}} \sum_{\mathcal{T}}s_{i}\right)\left(\sum_{\mathbb{B}}\sum_{\mathcal{T}}s_{i} \right)^{T}}{M}$ $$

Here, $\mathcal{T}$ represents the spatial size dimension for Batch Norm layer or for LayerNorm layer, it signifies the product of the number of heads and the per-head dimension.

For the proof of this proposition and the extended computation of other type of layers are given in Appendix A.2 and Section A.3. Note that in the context of online and stochastic optimization, we can estimate the Kronecker factors by employing a straightforward exponentially Moving Average (EMA) scheme throughout the batches by

$$ $\displaystyle\mathcal{H}_{i}=\gamma_{1}\mathcal{H}_{i-1}+(1-\gamma_{2}) \mathcal{H}_{i},\,\mathcal{S}_{i}=\gamma_{1}\mathcal{S}_{i-1}+(1-\gamma_{2}) \mathcal{S}_{i},$ (3) $$

where $0<\gamma_{1},\gamma_{2}<1$ are the exponentially decaying factors. This EMA scheme is commonly used in methods involving diagonal or block-diagonal approximations to the curvature matrix (e.g. LeCun et al. (); Park et al. (); Schaul et al. (). Such schemes have the desirable property that they allow the curvature estimation to depend on much more data than what can be reasonably processed in a single mini-batch.

Investigation from Section 3.1 suggest that the FIM’s critical information predominantly resides along its diagonal. Building upon these insights, we propose a novel approximation for the FIM that conceptualizes the Kronecker factors as diagonal matrices, denoted as $\tilde{F}_{D_{i}}$ for layer $i$.

###### Proposition 3.2 .

Assume that $\mathcal{H}_{i}$ and $\mathcal{S}_{i}$ can be closely approximated by diagonal matrices, denoted by $\mathcal{H}_{D_{i}}$ and $\mathcal{S}_{D_{i}}$ respectively at layer $i$, such that $\mathcal{H}_{D_{i}}=\text{Diag}(\mathcal{H}_{i})$, $\mathcal{S}_{D_{i}}=\text{Diag}(\mathcal{S}_{i})$ where Diag denote the diagonal of a matrix. Then the Empirical FIM can be defined by

$$ $\displaystyle\tilde{F}_{D_{i}}\triangleq\mathcal{H}_{D_{i}}^{\prime}\otimes \mathcal{S}_{D_{i}}^{\prime}+\lambda,$ (4) $$

where $\mathcal{H}_{D_{i}}^{\prime}$ and $\mathcal{S}_{D_{i}}^{\prime}$ denote the Min-Max normalization of $\mathcal{H}_{D_{i}}$ and $\mathcal{S}_{D_{i}}$ (Patro & Sahu, ) and $\lambda$ is a regularization parameter.

This approximation strikes a balance between computational time and space complexity, and the accuracy of performance, as discussed in Section 4. We set the regularization parameter $\lambda=0.001$, which acts as a damping factor following Tikhonov regularization principles, enhancing computational stability and conditioning of the FIM. For foundational details on $\lambda$, refer to Martens & Grosse () and for methodology, see Appendix A.2. The closed-form solution for the augmented gradient $\triangle\theta_{t}$ is derived from the diagonal approximation of the FIM, given by $\triangle\theta_{t}=\tilde{F}_{D_{t}}^{-1}\nabla J(\theta_{t})$. Detailed derivation in Appendix A.2, this represents the AdaFisher optimizer’s update rule, focusing on the diagonal elements to reduce computational overhead while maintaining a reasonable FIM approximation. This strategic simplification enhances the efficiency of the optimization process, crucial for training deep neural networks where computational resources are limited.

###### Proposition 3.1 .

###### Proposition 3.2 .

### 3.3 Augmenting FIM into Adam

Figure: Figure 4: Comparison of FIM Diagonal Histograms during ResNet18 Training on CIFAR10: The figure displays the FIM diagonal elements for the first convolutional layer with Adam and AdaFisher over 1,000 training iterations.
Refer to caption: extracted/5936014/images/hist_Fisher.png

Adam, which combines the methodologies of RMSProp and momentum (Sutskever et al., ), updates parameters following $\theta_{t+1}=\theta_{t}-\alpha_{t}\frac{m_{t}}{v_{t}}$. Here, $\alpha_{t}$ represents the learning rate, while $m_{t}$ and $v_{t}$ denote the first and second moment estimates, respectively. Although Adam is widely used, its approximation of the second moment using simple diagonal elements of second order statistics through squared gradients (Kunstner et al., ) can mirror stability challenges observed in simpler methods like SGD (Ruder, ). To overcome these limitations, we introduce AdaFisher, which utilizes a more refined diagonal block-Kronecker approximation of the FIM, derived using the K-FAC framework. This enhancement significantly improves curvature understanding and optimization dynamics. AdaFisher distinguishes itself from Adam by incorporating a higher fidelity approximation of the FIM, enhancing both optimization efficiency and model robustness in complex scenarios. As demonstrated in Figure 4, AdaFisher’s FIM values exhibit narrow variations and lower mean values during training, suggesting a convergence towards flatter local minima. In contrast, Adam shows broader variations, indicating less efficient convergence. For more details regarding the convergence behavior refer to Appendix B.1. Moreover, AdaFisher omits the square root and the traditional EMA applied over the second moment, since the FIM naturally incorporates an EMA of its Kronecker factors (detailed in Eq. (3)). The exclusion of the square root aligns with the theoretical definition of second order methods, as using a square root deviates from the second-order Taylor expansion approximation that these methods aim to follow. A comparative summary of different moment estimates, $m_{t}$ and $v_{t}$, along with their regret bounds and applicability across various optimizers, is presented in Table 1. Building on the principles of AdamW (Loshchilov & Hutter, ), which modifies Adam by integrating weight decay directly into the weight update step to counteract suboptimal decay behaviors and boost optimization performance, we introduce AdaFisherW. This variant adapts the AdamW framework to further enhance the optimizer by leveraging curvature information from AdaFisher. Finally, AdaFisher is compatible with multi-GPU environments, with a distributed version detailed in Appendix A.4. The implementation for both AdaFisher(^1^11PyTorch implementation is available from [https://github.com/AtlasAnalyticsLab/AdaFisher](https://github.com/AtlasAnalyticsLab/AdaFisher).) variants are delineated in the pseudo-code presented in Algorithm 1.

**Table 1: Summary of the first, second moments, regret bound and Applicability used in Adam Kingma & Ba (), AdaHessian Yao et al. (), K-FAC Martens & Grosse (), Shampoo Gupta et al. (), and AdaFisher for updating model parameters $\theta_{t+1}=\theta_{t}-\eta m_{t}/\sqrt{v_{t}}$. Here $\beta_{1}$ and $\beta_{2}$ are first and second moment hyperparameters. $L_{t}$ and $R_{t}$ refer to the preconditioning method used by Shampoo Gupta et al. (), $g_{t}=\text{vec}(G_{t})$, and $T$ denotes the total number of steps. Note that Trans. denotes Transformers**
| Optimizer | $m_{t}$ | $v_{t}$ | Regret Bound | Applicability |  |
| --- | --- | --- | --- | --- | --- |
|  |  |  |  | CNNs | Trans. |
| Adam | $\frac{(1-\beta_{1})\sum_{i=1}^{t}\beta_{1}^{t-i}g_{i}}{1-\beta_{1}^{t}}$ | $\left(\frac{(1-\beta_{2})\sum_{i=1}^{t}\beta_{2}^{t-i}g_{i}g_{i}}{1-\beta_{2}^<br>{t}}\right)^{1/2}$ | $O(\log T\sqrt{T})$ | $\checkmark$ | $\checkmark$ |
| AdaHessian | $\frac{(1-\beta_{1})\sum_{i=1}^{t}\beta_{1}^{t-i}g_{i}}{1-\beta_{1}^{t}}$ | $\left(\frac{(1-\beta_{2})\sum_{i=1}^{t}\beta_{2}^{t-i}D_{i}^{(s)}D_{i}^{(s)}}{<br>1-\beta_{2}^{t}}\right)^{1/2}$ | $O(\log T\sqrt{T})$ | $\checkmark$ | $\checkmark$ |
| K-FAC | $\hat{F}^{-1}g_{t}$ | 1 | $O(\sqrt{T})$ | $\checkmark$ | $\times$ |
| Shampoo | $L_{t}^{-1/4}G_{t}R_{t}^{-1/4}$ | 1 | $O(\sqrt{T})$ | $\checkmark$ | $\times$ |
| AdaFisher | $\frac{(1-\beta_{1})\sum_{i=1}^{t}\beta_{1}^{t-i}g_{i}}{1-\beta_{1}^{t}}$ | $\tilde{F}_{D_{t}}$ | $O(\log T\sqrt{T})$ | $\checkmark$ | $\checkmark$ |

Figure: Algorithm 1 AdaFisher optimization algorithm. Good default settings for the tested machine learning problems are $\alpha=0.001$ (learning rate), $\lambda=0.001$ (Tikhonov damping parameter), $\gamma_{1}=0.92$, $\gamma_{2}=0.0008$ (Exponentially decaying factors). [Default parameters are: $\beta=0.9$ (Exponentially decaying factor of Adam), $\kappa$ (weight decay) (Kingma & Ba (), Loshchilov & Hutter ())].

### 3.4 Convergence Analysis

In this section, we provide a theoretical analysis of AdaFisher’s convergence in both convex optimization and non-convex stochastic optimization. We first present a standard convergence behaviour
of Eq. (2) for a simple strongly convex and
strictly smooth function $f(J)$.

###### Proposition 3.3 (Convergence in convex optimization) .

For FIM defined in Eq. (4), the updating scheme $\triangle\theta_{t}=\tilde{F}^{-1}_{t}\nabla J(\theta_{t})$ converges. Further, if $\nabla J$ is Lipschitz, the convergence rate is bounded.

For non-convex case, we adopt the similar derivations of Chen et al. (), since AdaFisher belongs to the family of generalized Adam-type methods.

###### Proposition 3.4 (Convergence in non-convex stochastic optimization) .

Under the assumptions:
(i) $J$ is lower bounded and differentiable; $||\nabla J(\theta)-\nabla J(\theta^{\prime})||_{2}\leq L||\theta-\theta^{
\prime}||_{2}$, $||\tilde{F}_{D_{t}}||_{\infty}<L,\,\forall t,\theta,\theta^{\prime}$, (ii) Both the true and stochastic gradient are bounded, i.e. $||\nabla J(\theta_{t})||_{2}\leq\lambda$ and $||g_{t}||_{2}\leq\lambda$, $\forall t$ for some $\lambda>0$, (iii) Unbiased and independent noise in $g_{t}$, i.e. $g_{t}=\nabla J(\theta_{t})+\zeta_{t}$, $\mathbb{E}[\zeta_{t}]=0$, and $\zeta_{i}\perp\zeta_{j}$, $\forall i\neq j$. Assume $\eta_{t}=\frac{\eta}{\sqrt{t}}$, $\beta_{t}\leq\beta\leq 1$ is non-increasing, $\frac{\tilde{F}_{D_{t-1}}[j]}{\eta_{t-1}}\leq\frac{\tilde{F}_{D_{t}}[j]}{\eta_
{t}}$, $\forall t\in[T],j\in[d]$, we then have

$$ $\min_{t\in[T]}\mathbb{E}[||\nabla J(\theta_{t})||_{2}^{2}]\leq\frac{L}{\sqrt{T }}(C_{1}\eta^{2}\lambda^{2}(1+\log T)+C_{2}d\eta+C_{3}d\eta^{2}+C_{4})$ (5) $$

where $C_{1},C_{2},C_{3}$ are constants independent of $d$ and $T$, $C_{4}$ is a constant independent of $T$, the expectation is taken w.r.t all the randomness corresponding to $\{g_{t}\}$.

Proposition 3.4 implies the convergence rate for AdaFisher in the non-convex case is at $O(\log T/\sqrt{T})$, which is similar to Adam-type optimizer.

###### Proposition 3.3 (Convergence in convex optimization) .

###### Proposition 3.4 (Convergence in non-convex stochastic optimization) .

## 4 Results

To evaluate AdaFisher, we conduct experiments on six benchmark datasets across Image Classification for Computer Vision (CV) and Language Modelling for Natural Language Processing (NLP) that are commonly used to evaluate optimization algorithms: CIFAR-10, CIFAR100 (Krizhevsky et al., ), TinyImageNet (Le & Yang, ), and ImageNet (Deng et al., ) for image classification; Wikitext-2 (Merity et al., ) and Penn Treebank (PTB) (Marcus et al., ) for language modelling. The five baseline methods we compare with are Adam, K-FAC, AdaHessian, and Shampoo. For CIFAR experiments, we report the average over 5 runs. We also perform a transfer learning task for Image Classification using the Pytorch ImageNetV1 weights Paszke et al. (). Detailed descriptions of the experimental setups (including hyperparameters, datasets, and data augmentation), results, and analyses are provided in Appendix D.

**Table 2: Performance metrics (mean, std) of different networks and optimizers on CIFAR10 and CIFAR100 using batch size 256 with a 200-epoch AdaFisher training cutoff.**
|  | CIFAR10 | CIFAR100 |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Network | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher |
| ResNet18 | $94.85_{0.10}$ | $95.44_{0.08}$ | $95.17_{0.16}$ | $94.08_{0.20}$ | $\mathbf{96.25_{0.17}}$ | $75.74_{0.09}$ | $71.79_{0.21}$ | $76.03_{0.33}$ | $76.78_{0.16}$ | $\mathbf{77.28_{0.21}}$ |
| ResNet50 | $94.45_{018}$ | $95.54_{0.11}$ | $95.66_{0.14}$ | $94.59_{0.09}$ | $\mathbf{96.34_{0.21}}$ | $74.65_{0.46}$ | $75.81_{0.31}$ | $77.40_{0.38}$ | $78.07_{0.35}$ | $\mathbf{79.77_{0.35}}$ |
| ResNet101 | $94.57_{0.14}$ | $95.29_{0.64}$ | $96.01_{0.13}$ | $94.63_{0.1}$ | $\mathbf{96.39_{0.09}}$ | $75.56_{0.34}$ | $73.38_{0.23}$ | $77.01_{0.39}$ | $78.83_{0.16}$ | $\mathbf{80.65_{0.48}}$ |
| DenseNet121 | $94.86_{0.14}$ | $96.11_{0.05}$ | $96.12_{0.07}$ | $95.66_{0.07}$ | $\mathbf{96.72_{0.04}}$ | $75.87_{0.43}$ | $74.80_{0.89}$ | $79.79_{0.22}$ | $80.24_{0.25}$ | $\mathbf{81.36_{0.28}}$ |
| MobileNetV3 | $93.32_{0.13}$ | $92.86_{3.06}$ | $94.34_{0.14}$ | $93.81_{0.19}$ | $\mathbf{95.28_{0.10}}$ | $70.62_{0.34}$ | $56.58_{4.54}$ | $73.75_{0.262}$ | $70.85_{0.27}$ | $\mathbf{77.56_{0.13}}$ |
| Tiny Swin | $87.37_{0.62}$ | $84.15_{0.23}$ | $64.79_{0.47}$ | $63.91_{0.43}$ | $\mathbf{88.74_{0.39}}$ | $60.21_{0.41}$ | $56.86_{0.45}$ | $34.45_{0.41}$ | $30.39_{1.21}$ | $\mathbf{66.05_{0.46}}$ |
| FocalNet | $86.23_{0.06}$ | $64.18_{0.16}$ | $38.94_{0.81}$ | $37.96_{0.65}$ | $\mathbf{87.90}_{0.14}$ | $52.71_{0.48}$ | $32.33_{0.28}$ | $9.98_{0.57}$ | $9.18_{0.14}$ | $\mathbf{53.69_{0.37}}$ |
| CCT-2/3$\times$2 | $83.89_{0.38}$ | $-$ | $33.08_{2.31}$ | $35.16_{0.35}$ | $\mathbf{84.94}_{0.28}$ | $59.78_{0.51}$ | $-$ | $7.17_{0.21}$ | $8.60_{0.13}$ | $\mathbf{62.91_{0.54}}$ |

### 4.1 Image Classification

We commence our analysis by assessing the convergence and generalization capabilities of various models on image classification tasks. Specifically, we deploy ResNet architectures (ResNetX where $X\in\{18,50,101\}$), MobileNetV3 (Howard et al., ), Tiny Swin (Liu et al., ), FocalNet (Yang et al., ) and CCT-2/3$\times$2 (Hassani et al., ) on CIFAR10 and CIFAR100, while utilizing standard ResNet50 for TinyImageNet and ImageNet. The performance outcomes for CIFAR datasets are detailed in Table 2. Our empirical evaluation of AdaFisher optimizer across these models and datasets illustrates its efficiency in optimizing in image classification, surpassing contemporary state-of-the-art (SOTA) optimizers, including Adam, AdamW, AdaHessian, Shampoo, and K-FAC. We employ the Wall-Clock-Time (WCT) method with a cutoff of 200 epochs for AdaFisher’s training, except for ImageNet, where we use a 90-epoch WCT for Adam, which surprisingly matched AdaFisher’s training duration. Results confirm AdaFisher’s superior classification accuracy on both CNNs and VITs. Please note that the results for Tiny ImageNet are described in Appendix D.2.4.

ImageNet Training. Training on ImageNet typically demands multiple GPUs and large batch sizes. Our study demonstrates that AdaFisher achieves superior validation accuracy on a single GPU, outperforming baseline optimizers in scenarios marked by the light blue region in Table 4.1. While AdaFisher delivers
SOTA results on a single GPU, its performance further improves when scaled in a distributed setting with larger batch sizes. Additionally, AdaFisher surpasses traditional optimizers such as Momentum, LAMB (You et al., ), and LARS (You et al., ), which typically utilize batch sizes of 16K. It is important to note, however, that the training setups and augmentation techniques for the results highlighted in orange, taken from the literature, may differ from those in our study. These results are included to provide a broader context and intuition regarding AdaFisher’s performance compared to other experiments. Our benchmarks, conducted with a batch size of 256 over 90 Adam training epochs, are presented in Table 4.1 and visualized in Figure 6. The light blue highlights represent experiments on a single GPU with a batch size of 256, while the light green marks results from distributed AdaFisher using larger batch sizes. The orange highlights correspond to SOTA methods using batch sizes of 16K or Momentum with a batch size of 256. Overall, AdaFisher demonstrates strong generalization capabilities, in contrast to K-FAC, which tends to overfit under similar conditions.

Figure: Figure 5: Validation of ImageNet-1K / ResNet50 by different optimizers reported on Top-1 and Top-5 accuracy.
Refer to caption: extracted/5936014/images/testaccuracy_trainloss_ImageNet.png

### 4.2 Transfer Learning

Owing to global warming concerns, more sustainable practices are essential in training DNNs. Employing pretrained models from ImageNet-1k by PyTorch for transfer learning on datasets like CIFAR10 and CIFAR100 reduces the carbon footprint and leverages prior computations, promoting eco-friendly AI methodologies.
We applied these pretrained weights across various CNN architectures, to train on these datasets. The results, presented in Table 3, highlight the significant advantages of using AdaFisher, consistently achieving top accuracy across both datasets. More details can be found in Appendix D.2.3.

**Table 3: Performance comparison of different networks and optimizers on CIFAR10 and CIFAR100 using ImageNet-1K pretrained weights. Evaluation is based on wall clock time of 50 training epochs with AdaFisher.**
|  | CIFAR10 | CIFAR100 |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Network | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher |
| ResNet50 | $96.45_{0.18}$ | $96.35_{0.31}$ | $96.45_{0.14}$ | $96.03_{0.36}$ | $\mathbf{97.13_{0.20}}$ | $82.01_{0.42}$ | $80.64_{0.88}$ | $80.55_{0.40}$ | $81.70_{0.23}$ | $\mathbf{82.23_{0.25}}$ |
| ResNet101 | $96.70_{0.12}$ | $96.65_{0.15}$ | $96.84_{0.07}$ | $96.63_{0.13}$ | $\mathbf{97.22_{0.12}}$ | $82.43_{0.22}$ | $81.36_{0.78}$ | $82.26_{0.29}$ | $82.65_{0.17}$ | $\mathbf{84.47_{0.21}}$ |
| DenseNet121 | $94.77_{0.12}$ | $93.08_{0.11}$ | $94.41_{0.18}$ | $94.76_{0.14}$ | $\mathbf{95.03_{0.10}}$ | $75.65_{0.27}$ | $71.06_{0.90}$ | $76.10_{0.29}$ | $76.08_{0.23}$ | $\mathbf{76.92_{0.26}}$ |
| MobileNetV3 | $90.92_{0.30}$ | $86.45_{2.52}$ | $91.72_{0.19}$ | $91.39_{0.30}$ | $\mathbf{92.78_{0.17}}$ | $66.11_{0.78}$ | $59.69_{2.32}$ | $69.85_{0.38}$ | $68.87_{0.27}$ | $\mathbf{72.38_{0.36}}$ |

### 4.3 Language Model

**Table 4: Language Modelling performance (PPL) on Wikitext-2 and PTB test dataset (lower is better).**
| Optimizer | Test PPL |  |
| --- | --- | --- |
|  | WikiText-2 | PTB |
| AdamW | $175.06$ | $44.70$ |
| AdaHessian | $407.69$ | $59.43$ |
| Shampoo | $1727.75$ | $-$ |
| AdaFisherW | $\mathbf{152.72}$ | $\mathbf{41.15}$ |

We employ the WikiText-2 dataset, which encompasses approximately 100 million tokens derived from over 2 million words extracted from a curated set of ‘Good’ and ‘Featured’ articles on Wikipedia. Additionally, we utilize the PTB dataset, renowned for its extensive collection of English words with part-of-speech tags, which has been widely used in natural language processing tasks for training and benchmarking language models. Our experiments utilize a scaled-down version of GPT-1 (Radford et al., ), featuring four self-attention layers with masking capabilities with a total of 28,351,488 learnable parameters. More details about hyperparameters and model can be found in Appendix D.3. The perplexity (PPL) on the test set, corresponding to the best-performing model during validation, is documented in Table 4. Similar to approaches in image classification, we apply the WCT method with 50 epochs training time of AdaFisher as the cutoff period. Notice that Shampoo did not achieve convergence despite using optimal hyperparameters, and the K-FAC was unable to train effectively with the ASDL library (Osawa et al., ).

### 4.4 Stability Analysis

In this section, we assess AdaFisher’s stability under varying learning rates and batch sizes using ResNet50 on CIFAR100 and compare its performance to other optimizers. Improved stability indicates a reduced need for hyperparameter tuning while maintaining high performance. To ensure a fair comparison, all methods were evaluated using a consistent experimental setup, with parameters tailored to each optimizer’s strengths. However, we exclude AdaHessian results for a batch size of 1024 due to its significant computational cost.

Batch Size Analysis. We examine the impact of batch size on AdaFisher’s performance, as shown in Panels (A) and (C) of Figure 7. AdaFisher maintains high test accuracy across various batch sizes, excelling particularly at smaller sizes despite some sensitivity to larger ones. Panel (C) highlights AdaFisher’s efficiency, achieving high accuracy with shorter epoch times compared to Adam, detailed further in Panel (D) where AdaFisher shows competitive epoch durations against other optimizers. These results, discussed in Appendix D.2.5, underscore AdaFisher’s effective performance across batch size variations without adjusting other hyperparameters.

Learning Rate Stability. This analysis evaluates the impact of learning rate variations on AdaFisher’s performance, as depicted in Panel (B) of Figure 7. AdaFisher demonstrates superior stability, particularly at lower learning rates, maintaining consistent performance across a broad spectrum. This stability alleviates the need for meticulous learning rate adjustments, thereby streamlining model training in various computational environments. Additionally, AdaFisher’s stability across various learning rates can be attributed to its effective approximation of the curvature matrix.

Ablation Studies. We further conduct extensive ablation studies on additional components of AdaFisher, including the convergence efficiency, our novel approximation of the FIM, the significance of EMA for Kronecker factors, the impact of the square root, the stability across learning rate schedulers and the updated computation of the FIM for normalization layers. These analyses are thoroughly detailed in Appendix B.

Figure: Figure 7: Performance comparison of AdaFisher and other optimizers using the ResNet50 network on the CIFAR100 dataset. (A) Test accuracy by batch size. (B) Accuracy vs. learning rates. (C) Accuracy related to epoch time across batch sizes. (D) Epoch time for different optimizers with batch size of 256.
Refer to caption: extracted/5936014/images/stability_cifar100_3.png

## 5 Related work

Tractable Approximation of the FIM.
Efficient approximations of the FIM for neural network optimization have evolved significantly, beginning with block-diagonal strategies exemplified by TONGA (Roux et al., ) and extending to the Kronecker-factored approaches like K-FAC. Further innovations have emerged, such as SK-FAC (Tang et al., ), which accelerates the computation of the FIM, and Eschenhagen et al. (), who propose a generalized framework for FIM computation that enhances preconditioning methods like Shampoo. More recently, Huang et al. () have introduced a tractable solution for computing the FIM in continuous-time models. AdaFisher distinguishes itself by integrating enhanced FIM computations with novel diagonal Kronecker factors, enriching the Adam optimization framework. This integration, outlined in Proposition 3.2 and detailed in Appendix A.3, advances the fusion of second-order optimization principles with first-order methods. This builds upon innovations like AdaHessian, which incorporates Hessian diagonals into the Adam framework, thereby demonstrating the efficacy of such hybrid approaches.

Adaptive First-Order Methods.
Building upon the diagonal approximation heritage of the FIM, AdaFisher extends traditional diagonally-scaled first-order methods such as AdaGrad (Duchi et al., ), AdamP, AdaInject, AdaBelief, and Adam. These methods have inspired advancements like AMSGrad (Reddi et al., ), AdaBound (Luo et al., ), RAdam (Liu et al., ), and enhanced AdaBelief, improving both theoretical rigor and practical effectiveness. A recent study by Jiang et al. () illustrates that first-order adaptive methods can bias training trajectories and effectively navigate through saddle points. In response, Mishchenko & Stich () propose an empirical solution involving the addition of noise to mitigate these biases. Leplat et al. () introduces a novel method accelerating convergence via Gauss-Seidel type discretization. AdaFisher differentiates itself by eliminating the conventional square root in the second moment calculation, with benefits underscored by Lin et al. () and Malladi et al. () in CNN architectures, and Zhang et al. () demonstrates the critical role of Adam family optimizers in Transformer models. Its unique preconditioning, based on the Fisher Information, is elaborated in Algorithm 1.

## 6 Conclusion, Limitations and Future Research

In this work, we introduced AdaFisher, an adaptive optimizer that leverages a novel diagonal block-Kronecker approximation of the FIM to improve gradient rescaling and descent directions. Incorporated within the Adam framework, AdaFisher speeds up training, reduces hyperparameter sensitivity, and delivers higher accuracy and stability across image classification and language modeling tasks. Empirical and theoretical analyses demonstrate its superiority over current optimizers, with efficient space and time usage facilitating its application across diverse tasks. Notably, AdaFisher excels in SOTA comparisons on ImageNet under both single and multi-GPU setups.

Although optimized for statistical tasks, AdaFisher is less suited for tasks involving non-exponential loss families due to its reliance on statistical data for FIM computation.

Future work will expand testing to other models and areas, such as generative modeling (diffusion models) and graph neural networks, and developing CUDA kernels for Kronecker factors could greatly improve AdaFisher’s scalability and performance.

## Impact Statement

AdaFisher represents a significant advancement in training efficiency, achieving superior accuracy on the ImageNet dataset using only a single GPU. This optimization is particularly beneficial for academia and students who may not have access to extensive computational resources. By enabling effective training with fewer GPUs, AdaFisher offers an accessible yet powerful solution, reducing hardware costs and making advanced machine learning more attainable for those with limited resources. This capability underscores AdaFisher’s potential as a valuable tool in democratizing machine learning technology.

## Acknowledgment

This research is funded by Natural Sciences & Engineering Research Council (NSERC)-Discovery Grant RGPIN‐2022‐05378 [M.H.]; FRQNT-NSERC grant 2023-NOVA-329125 [E.B.& G.W.]; Canada CIFAR AI Chair, NSF DMS grant 2327211 and NSERC Discovery grant 03267 [G.W.]

## Appendix A Theory

### A.1 Kronecker Factors: A Structural Examination (Continue)

In the realm of matrix theory, Gersgorin’s Circle Theorem offers a principle for localizing the eigenvalues of a complex square matrix, asserting that each eigenvalue is situated within at least one Gersgorin disk. These disks are defined by the matrix’s diagonal elements and the sum of the absolute values of the respective off-diagonal row entries. Formally, the theorem is stated as follows:

###### Theorem A.1 (Gersgorin Circle Theorem) .

Let $\mathcal{A}$ be a complex square matrix with eigenvalues $\lambda$. For each $\lambda$, there exists an index $i$ such that:

$$ $|\lambda-\mathcal{A}_{ii}|\leq\sum_{\begin{subarray}{c}j=1\\ j\neq i\end{subarray}}^{n}|\mathcal{A}_{ij}|,$ $$

where the summation excludes the diagonal entry $\mathcal{A}_{ii}$.

For a detailed proof of Theorem A.1, the reader is referred to the seminal work by Horn and Johnson Horn & Johnson ().
Extending the application of Gersgorin’s Circle Theorem to the study of Kronecker factors within deep neural networks, we analyze these factors from both convolutional ($37$th) and linear ($41$st) layers of a ResNet-18 network, post-training on CIFAR10 dataset. As elucidated in Section 3.1, leveraging Theorem A.1 demonstrates that the eigenvalues of the Kronecker factors from the convolutional layer are predominantly concentrated along the diagonal. This observation is analogously applicable to the linear layer. Figure 3 showcases the Gersgorin disks for the 41st (linear) layer, with the eigenvalues (red crosses) significantly clustered within these disks (centered at the black circles), underscoring a pronounced diagonal dominance. Moreover, upon introducing Gaussian noise to the off-diagonal elements following this shceme: $\hat{\mathcal{M}}=\mathcal{A}+\mathcal{E},\quad\text{where }\mathcal{E}=[e_{ij
}]\text{ and }e_{ij}\sim\mathcal{N}(0,\sigma^{2})\text{ for }i\neq j$, the perturbation analysis elucidates that such stochastic variations engender only marginal displacements in the eigenvalues. Notably, those eigenvalues fulfilling the Kaiser criterion are minimally affected, substantiating the resilience of the diagonal dominance against noise-induced perturbations.

Figure: Figure 8: Gersgorin disks and eigenvalue perturbation analysis for matrices $\mathcal{H}$ and $\mathcal{S}$ at training steps 5200 (middle of training) and 9800 (end of training) in a ResNet-18 Network’s Linear Layer ($41$st Layer). The left panel depicts the Gersgorin’s circles in the complex plane, while the right panel illustrates the magnitude spectrum of eigenvalues with and without the influence of Gaussian noise.
Refer to caption: extracted/5936014/images/analysis_Linear41.png

Our next analysis focus centers on elucidating the behaviors of matrices through consecutive steps in the frequency domain, thereby highlighting the intricate patterns and transformations emergent from the training process. By deploying a Fast Fourier Transform (FFT) on $\mathcal{H}$ and $\mathcal{S}$, along with their noise-infused variants $\hat{\mathcal{H}}$ and $\hat{\mathcal{S}}$, we aim to dissect the spectral nuances of these factors. The deliberate addition of noise to the off-diagonal serves as a probe to validate our hypothesis that the pivotal information of the Kronecker factors is predominantly concentrated along their diagonals. The minimal impact of such noise perturbations observed empirically underscores this diagonal dominance. Our analysis aims to juxtapose the frequency domain representations of both the uncontaminated and the noise-affected matrices at assorted iterative phases, thereby illuminating the inherent stability and tenacity of the Kronecker structures amidst stochastic disturbances.
Let $A$ be a two-dimensional $m\times n$ matrix. The FFT of $A$, denoted as $\mathcal{F}(A)$, is computed as:

$$ $\mathcal{F}(A)_{kl}=\sum_{p=0}^{m-1}\sum_{q=0}^{n-1}A_{pq}\cdot e^{-2\pi i \left(\frac{pk}{m}+\frac{ql}{n}\right)},$ (6) $$

where $\mathcal{F}(A)_{kl}$ is the value of the FFT at the $k$-th row and $l$-th column of the transformed matrix, $A_{pq}$ is the value of the original matrix at the $p$-th row and $q$-th column, and $i$ is the imaginary unit (Oppenheim et al., ).

Figure: Figure 9: Comparative Visualization of FFT Outputs for Kronecker Factors in a ResNet-18 Network’s Convolutional and Linear Layers. (A) FFT results for Kronecker factors $\mathcal{H}$ and $\hat{\mathcal{H}}$ from the $37$th convolutional layer under noise-free conditions (top) and with Gaussian noise (bottom) at iterations 5200 (middle of training) and 9800 (end of training). (B) Analogous FFT results for Kronecker factors $\mathcal{S}$ and $\hat{\mathcal{S}}$ from the $41$st linear layer, also contrasted between noise-free (top) and noisy conditions (bottom) at the same iterations.
Refer to caption: extracted/5936014/images/fft_analysis.jpg

Figure 9 demonstrates the Fourier spectral analysis of the Kronecker factors $\mathcal{H}$ and $\mathcal{S}$ over two distinct iterative stages of training—5200 and 9800 for a convolutional and linear layers ($37$th and $41$st of a ResNet-18 network respectively). Each Kronecker factor is analyzed via FFT in both a pristine, noise-free condition and a Gaussian noise-affected state, with the associated Signal-to-Noise Ratios (SNRs) detailed in Eq. (7). In the noise-free FFT spectra, a pronounced diagonal energy concentration is manifest in the $\mathcal{H}$ and $\mathcal{S}$ factors of the convolutional layer, indicative of significant informational preservation along the diagonal. In contrast, the linear layer exhibits a less pronounced but still discernible diagonal energy distribution, suggesting a more diffuse yet still noteworthy diagonal information structure. With the addition of noise, the matrices $\hat{\mathcal{H}}$ and $\hat{\mathcal{S}}$ still display a notable diagonal pattern, indicating minimal SNR deterioration. This observation supports the proposition that the kronecker factors primarily encode their information along the diagonal, and the introduction of noise into the off-diagonal elements has a limited impact.
The SNR between a matrix $\mathcal{M}$ and $\hat{\mathcal{M}}$ is computed using the formula:

$$ $\text{SNR}=10\cdot\log_{10}\left(\frac{\sum_{i=1}^{N}|\mathcal{M}_{ii}|^{2}}{ \sum_{j>i}^{N}|\hat{\mathcal{M}}_{ij}|^{2}}\right),$ (7) $$

where $\mathcal{M}_{ii}$ denotes the diagonal elements of $\mathcal{M}$, and $\hat{\mathcal{M}}_{ij}$ represents the upper triangular elements of $\hat{\mathcal{M}}$ excluding the diagonal (Oppenheim et al., ). The observed reduction in SNR from step 5200 to step 9800 for the Kronecker factor $\mathcal{S}$ in the convolutional layer, under noisy conditions, could suggest an incremental integration of noise effects across iterations. Conversely, for the remaining factors, an increase in SNR throughout the training process is detected, which may indicate an enhancement in signal clarity. Nevertheless, the integrity of the diagonal concentration of energy remains predominantly intact, demonstrating the underlying robustness of the network’s feature extraction capability against noise perturbations. Ultimately, the spectral analyses validate the hypothesis that the Kronecker factors’ informational content is predominantly diagonal and resistant to the effects of off-diagonal Gaussian noise. This durability is sustained through successive iterations, maintaining the primary spectral characteristics of the Kronecker factors.

Figure: Figure 10: Visualization of Kronecker Factors $\mathcal{H}$ and $\mathcal{S}$ for convolutional (A) and linear (B) layers at different iteration steps within a ResNet-18 network. For the convolutional layer ($37$th layer), the first two plots in (A) represent factor $\mathcal{H}$ at steps 5200 (middle of training) and 9800 (end of training), elucidating the matrix’s structure at these stages. The subsequent two plots display factor $\mathcal{S}$, highlighting changes in granularity and contrast with iteration progression. Similarly, in (B) for the linear layer ($41$st position), we observe the structural evolution of factor $\mathcal{H}$ and $\mathcal{S}$ over the same iterations, with variations in pattern density and clarity. These visualizations collectively underscore the dynamic nature of the Kronecker factors’ architecture as training advances.
Refer to caption: extracted/5936014/images/matrix_plot.jpg

Figure 10 offers a visual exposition of the Kronecker Product Factors $\mathcal{H}$ and $\mathcal{S}$ at progressive iteration junctures—specifically steps 5200 and 9800 for a convolutional and linear layers ($37$th and $41$st of a ResNet-18 network respectively). The initial duo of plots in each (A) and (B), delineate the Kronecker factor $\mathcal{H}$ at the aforementioned steps, elucidating the matrix’s structure at two distinct evolutionary stages. The next duo plots in (A) and (B) represents the Kronecker factor $\mathcal{S}$ at different steps of training. This visual examination, in conjunction with the preceding spectral analyses, articulates an integrated story of the developmental trajectory of the Kronecker factors. The enduring diagonal salience observed in both $\mathcal{H}$ and $\mathcal{S}$ underscores the notion that the informational energy of the Kronecker factors is predominantly concentrated along the diagonal. This persistent feature accentuates the structural stability and the focused nature of information encoding within the network’s layers.

###### Theorem A.1 (Gersgorin Circle Theorem) .

### A.2 Proofs

###### Proposition A.1 .

Consider a neural network layer indexed by $i$, and a mini-batch $\mathbb{B}\subset\mathbf{D}$ of size $M$ ($|\mathbb{B}|=M$). The empirical statistics of the Kronecker factors for the normalization layers can be characterized as follows:

$$ $\displaystyle\mathcal{H}_{i}=\frac{\left(\sum_{\mathbb{B}}\sum_{\mathcal{T}} \bar{h}_{i}\right)^{T}\left(\sum_{\mathbb{B}}\sum_{\mathcal{T}}\bar{h}_{i} \right)}{(M|\mathcal{T}|)^{2}},\,\mathcal{S}_{i}=\frac{\left(\sum_{\mathbb{B}} \sum_{\mathcal{T}}s_{i}\right)\left(\sum_{\mathbb{B}}\sum_{\mathcal{T}}s_{i} \right)^{T}}{M}$ (8) $$

Here, $\mathcal{T}$ represents the spatial size dimension for Batch Norm layer and for LayerNorm layer, it signifies the product of the number of heads and the per-head dimension.

###### Proof.

The justification of our approach will be split into two parts: the first for the Batch Normalization layer and the second for the Layer Normalization.

Part 1: Batch Normalization

Batch Normalization is a solution to the problem of internal covariance shifting for normalizing the layer inputs. For each activation $\bar{h}_{i}$ they introduce a pair of parameters $\nu_{i}$ and $\beta_{i}$ which scale and shift the normalized value:

$$ $\displaystyle y_{i}=\nu_{i}\bar{h}_{i}+\beta_{i}$ (9) $$

The FIM for Batch Normalization captures the sensitivity of the output with respect to the parameters $\nu{i}$ and $\beta_{i}$. We introduce rescaling and shifting operations into the FIM formulation to adapt for BatchNorm parameters, enabling efficient FIM approximation. For the multiplication operation in BatchNorm (scaling factor), we adjust the FIM calculation using Eq. (8) incorporating the batch size and spatial dimension. This normalization ensures FIM accounts for the BatchNorm scaling factors. Similarly, for the addition operation involving bias terms, we seamlessly integrate biases into the FIM formulation, capturing their impact on gradient computation. The shape of the Kronecker factors are defined as:

$$ $\displaystyle\mathcal{H}_{i}\in\mathbb{R}^{2\times 2},\,\,\mathcal{S}_{i}\in \mathbb{R}^{c_{i}\times c_{i}}$ $$

where $c_{i}$ refers to the channel dimension of layer $i$.

Part 2: Layer Normalization

Layer Normalization normalizes the inputs across the features instead of the batch dimension and the same equation, Eq. (9), is also used for Layer Normalization. Similar to Batch Normalization we introduce rescaling and shifting operations into the FIM formulation but adapted to the normalization across features rather than the batch. In fact, $\mathcal{T}$ refers here to the product of the number of heads and the per-head dimension rather than the spatial size dimension.The shape of the Kronecker factors for LayerNorm are:

$$ $\displaystyle\mathcal{H}_{i}\in\mathbb{R}^{2\times 2},\,\,\mathcal{S}_{i}\in \mathbb{R}^{|\mathcal{T}|\times|\mathcal{T}|}$ $$

∎

###### Proposition A.2 .

Let $\mathcal{H}_{i}$ and $\mathcal{S}_{i}$ represent the Kronecker factors for a given layer index $i$ within a neural network, where these factors exhibit semi-diagonal characteristics indicating energy concentration predominantly along the diagonal, as elaborated in Section 3.1. Define $g_{i}$ as the gradient obtained through backpropagation at layer $i$. Assume that $\mathcal{H}_{i}$ and $\mathcal{S}_{i}$ can be closely approximated by diagonal matrices, denoted by $\mathcal{H}_{D_{i}}$ and $\mathcal{S}_{D_{i}}$ respectively at layer $i$, such that $\mathcal{H}_{D_{i}}=\text{Diag}(\mathcal{H}_{i})$, $\mathcal{S}_{D_{i}}=\text{Diag}(\mathcal{S}_{i})$ where $\text{Diag}(\mathcal{M})$ denote the diagonal approximation of a matrix $\mathcal{M}$, which retains only the main diagonal. Therefore we define the Empirical FIM as:

$$ $\displaystyle\tilde{F}_{D_{i}}\triangleq\mathcal{H}_{D_{i}}^{\prime}\otimes \mathcal{S}_{D_{i}}^{\prime}+\lambda,$ (10) $$

where $\mathcal{M}^{\prime}$ denotes the Min-Max normalization technique Patro & Sahu () for $\mathcal{M}=\mathcal{H}_{D_{i}}$ or $\mathcal{S}_{D_{i}}$. The regularization parameter $\lambda$ set to $0.001$, serves as damping factors, in alignment with the principles of Tikhonov regularization, to enhance computational stability and improve the conditioning of the matrix. The foundational aspects of the K-FAC optimization approach are detailed in Martens & Grosse (). For a comprehensive account of the methodology and construction details, please consult Appendix A.2. Then, the closed-form solution for the augmented gradient $\hat{g}_{i}$, derived from the diagonal approximation of the FIM, is given by: $\hat{g}_{i}=\tilde{F}_{D_{i}}^{-1}g_{i}$.

###### Proof.

The justification of our approach comprises two principal components: the rationale for adopting a diagonal approximation of the Kronecker factors, and the methodology for normalization and regularization of these factors.

Part 1: Diagonalization of Kronecker Factors

The assumption of independent neuronal activity within layers is foundational to our approach. This assumption posits that the covariance matrices $\mathcal{H}$ and $\mathcal{S}$, encapsulating the second-order statistics of activations and sensitivities, respectively, are diagonal. This diagonal nature arises because independence among random variables implies a covariance of zero for any pair of distinct variables, thereby nullifying all off-diagonal elements of these covariance matrices.

Consider matrices $A$ and $B$, each being diagonal with elements $a_{ii}$ and $b_{jj}$, respectively. The Kronecker product $A\otimes B$, by definition, generates elements $a_{ii}b_{jj}$ at the corresponding $(i,j)$ positions. For diagonal $A$ and $B$, this product maintains non-zero values exclusively at diagonal positions where $i=j$, resulting in:

$$ $A\otimes B=\text{diag}(a_{11}b_{11},\ldots,a_{nn}b_{mm}),$ (11) $$

yielding a purely diagonal matrix. Moreover, we have empirically demonstrated that the energy of the Kronecker factors is concentrated along the diagonal, as detailed in Sections 3.1 and A.1. These arguments supports our initial premise.

Part 2: Normalization and Regularization

Normalization plays a pivotal role in machine learning algorithms, particularly in ensuring numerical stability and improving convergence properties of optimization algorithms. When dealing with matrices such as $\mathcal{H}_{D_{i}}$ and $\mathcal{S}_{D_{i}}$, which exhibit a diagonal structure, normalization not only aids in adjusting the scale of matrix values but also addresses the issue of varying scales among different features. The adoption of Min-Max normalization for the diagonal elements $\mathcal{A}_{i}$ is especially advantageous as it standardizes the data to a fixed interval, commonly $[0,1]$, which is crucial for many gradient-based optimization methods. The transformed matrix $\tilde{\mathcal{A}}_{i}$ is mathematically defined as:

$$ $\tilde{\mathcal{A}}_{i}=\frac{\mathcal{A}_{i}-\min(\mathcal{A}_{i})}{\max( \mathcal{A}_{i})-\min(\mathcal{A}_{i})},$ (12) $$

where $\mathcal{A}_{i}$ represents the diagonal elements from either $\mathcal{H}_{D_{i}}$ or $\mathcal{S}_{D_{i}}$. This approach ensures that all elements are scaled uniformly, preserving their relative magnitudes and distances. The numerator, $\mathcal{A}_{i}-\min(\mathcal{A}_{i})$, shifts the values so that the minimum element is zero. The denominator, $\max(\mathcal{A}_{i})-\min(\mathcal{A}_{i})$, scales the range of values to fit between zero and one. Compared to other normalization methods, such as z-score normalization (Patro & Sahu, ), Min-Max normalization offers the distinct benefit of bounding the values, which prevents problems associated with unbounded ranges that can adversely affect learning processes, particularly in networks sensitive to input magnitude. Moreover, Min-Max normalization is advantageous in scenarios where the parameters are influenced by activation functions like sigmoid or tanh, which are sensitive to input scale and function optimally within a defined range of $[0,1]$ or $[-1,1]$. Thus, normalization, specifically using the Min-Max method, is crucial for maintaining computational stability in algorithms by ensuring that all input features contribute equally to the analysis without any undue influence from outliers or disproportionately large feature values. This uniformity facilitates faster convergence during training and mitigates the risk of encountering vanishing or exploding gradient issues in neural networks.

Together, these components substantiate the proposition, demonstrating that our methodological innovations not only adhere to theoretical expectations but also offer practical advantages in computational stability and efficiency.
∎

###### Proposition A.3 .

For the FIM defined in Eq. (10), the updating scheme $\triangle\theta_{t}=\tilde{F}^{-1}_{t}\nabla J(\theta_{t})$ converges. Moreover, if $\nabla J$ is Lipschitz, i.e., $||\nabla J(\theta)-\nabla J(\theta^{\prime})||_{2}\leq L||\theta-\theta^{
\prime}||$ for any $\theta$ and $\theta^{\prime}$, then for the $k$-step iteration with a fixed step size $\delta\leq 1/L$, then

$$ $J(\theta^{(k)})-J(\theta^{*})\leq\frac{||\theta^{(0)}-\theta^{*}||_{2}^{2}}{2 \delta k},$ $$

where $J(\theta^{*})$ is the optimal value.

###### Proof.

For convenience, we denote $g_{t}:=\nabla J(\theta_{t})$. We follow the same proof as in Yao et al. (). Assume that $J(\theta)$ is a strongly convex and strictly smooth function in $\mathbb{R}^{d}$, such that there exist positive constants $\alpha$ and $\beta$ so that $\alpha I\leq\nabla^{2}J(\theta)\leq\beta I$ for all $w$. We can show that the update formulation $\triangle\theta_{t}=\tilde{F}^{-1}_{t}g_{t}$ converges by showing that with the proper learning rate:

$$ $\triangle\theta_{t}:=J(\theta_{t+1})-J(\theta_{t})\leq-\frac{\alpha}{2\beta^{2 }}||g_{t}||^{2}$ $$

Note that when $k=0$ or 1, the convergence rate is the same as gradient descent or Newton method, respectively. Our proof is similar to Boyd & Vandenberghe () for Newton method. We denote $\lambda(\theta_{t})=(g_{t}^{T}\tilde{F}_{t}^{-1}g_{t})^{1/2}$. Since $J(\theta)$ is strongly convex, we have

$$ $\displaystyle J(\theta_{t}-\eta\triangle\theta_{t})$ $\displaystyle\leq J(\theta_{t})-\eta g_{t}^{T}\triangle\theta_{t}+\frac{\eta^{ 2}\beta||\triangle\theta_{t}||^{2}}{2}$ $\displaystyle\leq J(\theta_{t})-\eta\lambda(\theta_{t})^{2}+\frac{\beta}{2 \alpha}\eta^{2}\lambda(\theta_{t})^{2}.$ $$

The second inequality come from the fact that

$$ $\lambda(\theta_{t})^{2}=\triangle\theta_{t}^{T}\tilde{F}_{t}\triangle\theta_{t }\geq\alpha||\triangle\theta_{t}||^{2}.$ $$

Therefore, the step size $\hat{\eta}=\alpha/\beta$ will make $f$ decrease as follows,

$$ $J(\theta_{t}-\hat{\eta}\triangle\theta_{t})-J(\theta_{t})\leq-\frac{1}{2}\hat{ \eta}\lambda(\theta_{t})^{2}.$ $$

Since $\alpha I\preceq\tilde{F}_{t}\preceq\beta I$, we have

$$ $\lambda(\theta_{t})^{2}=g_{t}^{T}\tilde{F}_{t}^{-1}g_{t}\geq\frac{1}{\beta}||g _{t}||^{2}.$ $$

Therefore,

$$ $J(\theta_{t}-\hat{\eta}\triangle\theta_{t})-J(\theta_{t})\leq-\frac{1}{2\beta} \hat{\eta}||g_{t}||^{2}=-\frac{\alpha}{2\beta^{2}}||g_{t}||^{2}$ (13) $$

Since $F_{D_{t}}$ is positive definite, hence Eq. (13) holds true. For the bound on convergence rate, we refer to Ryu & Boyd () for the details of the complete proof.

∎

###### Proposition A.4 (Convergence in nonconvex stochastic optimization) .

Under the assumptions:
(i) $f$ is lower bounded and differentiable; $||\nabla J(\theta)-\nabla J(\theta^{\prime})||_{2}\leq L||\theta-\theta^{
\prime}||_{2}$, $||\tilde{F}_{D_{t}}||_{\infty}<L,\,\forall t,\theta,\theta^{\prime}$.
(ii) Both the true and stochastic gradient are bounded, i.e. $||\nabla J(\theta_{t})||_{2}\leq\lambda$ and $||g_{t}||_{2}\leq\lambda$, $\forall t$ for some $\lambda>0$.
(iii) Unbiased and independent noise in $g_{t}$, i.e. $g_{t}=\nabla J(\theta_{t})+\zeta_{t}$, $\mathbb{E}[\zeta_{t}]=0$, and $\zeta_{i}\perp\zeta_{j}$, $\forall i\neq j$.

Assume $\eta_{t}=\frac{\eta}{\sqrt{t}}$, $\beta_{t}\leq\beta\leq 1$ is non-increasing, $\frac{\tilde{F}_{D_{t-1}}[j]}{\eta_{t-1}}\leq\frac{\tilde{F}_{D_{t}}[j]}{\eta_
{t}}$, $\forall t\in[T],j\in[d]$, we then have

$$ $\min_{t\in[T]}\mathbb{E}[||\nabla J(\theta_{t})||_{2}^{2}]\leq\frac{L}{\sqrt{T }}(C_{1}\eta^{2}\lambda^{2}(1+\log T)+C_{2}d\eta+C_{3}d\eta^{2}+C_{4})$ (14) $$

where $C_{1},C_{2},C_{3}$ are constants independent of $d$ and $T$, $C_{4}$ is a constant independent of $T$, the expectation is taken w.r.t all the randomness corresponding to $\{g_{t}\}$.

###### Proof.

Follow Chen et al. (), as AdaFisher is an Adam-type method with the condition $||\eta_{t}m_{t}/\tilde{F}_{D_{t}}||_{2}\leq G$ for some $G$ (which can be obtained by $\eta_{t}<\eta$, $||g_{t}||_{2}\leq\lambda$ and $||\tilde{F}_{D_{t}}||_{2}\geq 1$), we have

$$ $\displaystyle\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\eta_{t}\langle\nabla J(\theta_{t }),\nabla J(\theta_{t})/\tilde{F}_{D_{t}}\rangle\Bigg{]}\leq$ $\displaystyle\mathbb{E}\Bigg{[}C_{1}\sum_{t=1}^{T}\left\|\frac{\eta_{t}g_{t}}{ \tilde{F}_{D_{t}}}\right\|_{2}^{2}+C_{2}\sum_{t=1}^{T}\left\|\frac{\eta_{t}}{ \tilde{F}_{D_{t}}}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}}\right\|_{1}$ $\displaystyle+C_{3}\sum_{t=1}^{T}\left\|\frac{\eta_{t}}{\tilde{F}_{D_{t}}}- \frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}}\right\|_{2}^{2}\Bigg{]}+C_{4}.$ (15) $$

We first bound non-constant terms in RHS of Eq. (A.2). For the term with $C_{1}$, since $||\tilde{F}_{D_{t}}||_{2}\geq 1$, we have

$$ $\displaystyle\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\left\|\frac{\eta_{t}g_{t}}{ \tilde{F}_{D_{t}}}\right\|_{2}^{2}\Bigg{]}$ $\displaystyle\leq\mathbb{E}\Bigg{[}\sum_{t=1}^{T}||\eta_{t}g_{t}||_{2}^{2} \Bigg{]}$ $\displaystyle=\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\left\|\frac{\eta}{\sqrt{t}}g_{t }\right\|_{2}^{2}\Bigg{]}$ $\displaystyle\leq\eta^{2}\lambda^{2}\sum_{t=1}^{T}\frac{1}{t}\leq\eta^{2} \lambda^{2}(1+\log T).$ $$

For the term with $C_{2}$, we have

$$ $\displaystyle\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\left\|\frac{\eta_{t}}{\tilde{F}_ {D_{t}}}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}}\right\|_{1}\Bigg{]}$ $\displaystyle=\mathbb{E}\Bigg{[}\sum_{j=1}^{d}\sum_{t=2}^{T}\left(\frac{\eta_{ t-1}}{\tilde{F}_{D_{t-1}}[j]}-\frac{\eta_{t}}{\tilde{F}_{D_{t}}[j]}\right) \Bigg{]}$ $\displaystyle=\mathbb{E}\Bigg{[}\sum_{j=1}^{d}\frac{\eta_{1}}{\tilde{F}_{D_{1} }[j]}-\frac{\eta_{T}}{\tilde{F}_{D_{T}}[j]}\Bigg{]}$ $\displaystyle\leq\mathbb{E}\Bigg{[}\sum_{j=1}^{d}\frac{\eta_{1}}{\tilde{F}_{D_ {1}}[j]}\Bigg{]}\leq d\eta$ $$

where the first equality is due to $\frac{\tilde{F}_{D_{t-1}}[j]}{\eta_{t-1}}\leq\frac{\tilde{F}_{D_{t}}[j]}{\eta_
{t}}$, $\forall t\in[T],j\in[d]$.

For the term with $C_{3}$, we have

$$ $\displaystyle\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\left\|\frac{\eta_{t}}{\tilde{F}_ {D_{t}}}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}}\right\|_{2}^{2}\Bigg{]}$ $\displaystyle=\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\sum_{j=1}^{d}\left(\frac{\eta_{ t}}{\tilde{F}_{D_{t}}[j]}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}[j]}\right)^{2} \Bigg{]}$ $\displaystyle=\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\sum_{j=1}^{d}\left|\frac{\eta_{ t}}{\tilde{F}_{D_{t}}[j]}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}[j]}\right| \cdot\left|\frac{\eta_{t}}{\tilde{F}_{D_{t}}[j]}-\frac{\eta_{t-1}}{\tilde{F}_{ D_{t-1}}[j]}\right|\Bigg{]}$ $\displaystyle\leq\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\sum_{j=1}^{d}\left|\frac{ \eta_{t}}{\tilde{F}_{D_{t}}[j]}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}[j]} \right|\cdot\left|\frac{\eta}{\sqrt{t}\tilde{F}_{D_{t}}[j]}-\frac{\eta}{\sqrt{ t-1}\tilde{F}_{D_{t-1}}[j]}\right|\Bigg{]}$ $\displaystyle\leq\mathbb{E}\Bigg{[}\eta\sum_{t=1}^{T}\sum_{j=1}^{d}\left|\frac {\eta_{t}}{\tilde{F}_{D_{t}}[j]}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}[j]} \right|\Bigg{]}$ $\displaystyle=\eta\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\left\|\frac{\eta_{t}}{ \tilde{F}_{D_{t}}}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}}\right\|_{1}\Bigg{]}$ $\displaystyle\leq d\eta^{2}$ $$

Hence

$$ $\displaystyle\mathbb{E}\Bigg{[}C_{1}\sum_{t=1}^{T}\left\|\frac{\eta_{t}g_{t}}{ \tilde{F}_{D_{t}}}\right\|_{2}^{2}$ $\displaystyle+C_{2}\sum_{t=1}^{T}\left\|\frac{\eta_{t}}{\tilde{F}_{D_{t}}}- \frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}}\right\|_{1}+C_{3}\sum_{t=1}^{T}\left\| \frac{\eta_{t}}{\tilde{F}_{D_{t}}}-\frac{\eta_{t-1}}{\tilde{F}_{D_{t-1}}} \right\|_{2}^{2}\Bigg{]}+C_{4}$ $\displaystyle\leq C_{1}\eta^{2}\lambda^{2}(1+\log T)+C_{2}d\eta+C_{3}d\eta^{2} +C_{4}$ (16) $$

Now we lower bound the LHS of Eq. (14). With the assumption $||\tilde{F}_{D_{t}}||_{\infty}\leq L$, we have

$$ $(\eta_{t}/\tilde{F}_{D_{t}})_{j}\geq\frac{\eta}{L\sqrt{t}}.$ $$

Thus

$$ $\mathbb{E}\Bigg{[}\sum_{t=1}^{T}\eta_{t}\langle\nabla J(\theta_{t}),\nabla J( \theta_{t})/\tilde{F}_{D_{t}}\rangle\Bigg{]}\geq\mathbb{E}\Bigg{[}\sum_{t=1}^{ T}\frac{\eta}{L\sqrt{t}}||\nabla J(\theta_{t})||_{2}^{2}\Bigg{]}\geq\frac{ \sqrt{T}}{L}\min_{t\in[T]}\mathbb{E}[||\nabla J(\theta_{t})||_{2}^{2}]$ (17) $$

Combining Eq. (A.2) and (17) gives the desired result.
∎

###### Proposition A.1 .

###### Proof.

###### Proposition A.2 .

###### Proof.

###### Proposition A.3 .

###### Proof.

###### Proposition A.4 (Convergence in nonconvex stochastic optimization) .

###### Proof.

### A.3 Computation of Kronecker Factors

The Kronecker factors $\mathcal{H}$ and $\mathcal{S}$, which are integral to the AdaFisher optimizer, are computed following methodologies similar to those described in Grosse & Martens (). This section revisits the key equations used for this computation.
For a given layer $i$ in a neural network, consider a mini-batch $\mathbb{B}\subset\mathbf{D}$, where $|\mathbb{B}|=M$. The empirical Kronecker factors are computed as follows:

- •
For fully connected layers, the Kronecker factors are:
$\displaystyle\mathcal{H}_{D_{i}}=\text{diag}\left(\frac{\overline{h}_{i}^{T}
\overline{h}_{i}}{M}\right),\quad\mathcal{S}_{D_{i}}=\text{diag}\left(\frac{s_
{i}^{T}s_{i}}{M}\right);$
- •
For convolutional layers, the computation accounts for the spatial positions within the layer, denoted as $\mathcal{T}$:
$\displaystyle\mathcal{H}_{D_{i}}=\text{diag}\left(\frac{\llbracket\overline{h}
_{i}\rrbracket^{T}\llbracket\overline{h}_{i}\rrbracket}{M|\mathcal{T}|}\right)
,\quad\mathcal{S}_{D_{i}}=\text{diag}\left(\frac{s_{i}^{T}s_{i}}{M|\mathcal{T}
|}\right);$
The algorithm employs the expansion operation denoted by $\llbracket\cdot\rrbracket$ (Grosse & Martens, ). This operation essentially takes the patches surrounding spatial locations, stretches them into vectors, and compiles these vectors into a matrix
- •
For Normalization layers (BatchNorm & LayerNorm) please refer to Proposition. 3.1
- •
For all other type of layers the Kronecker factors are:
$\displaystyle\mathcal{H}_{D_{i}}=\textbf{I}_{d_{i}},\quad\mathcal{S}_{D_{i}}=
\textbf{I}_{d_{i}};$
where $d_{i}$ denotes the dimension of the $i$th layer and $\mathbf{I}$ is the identity matrix.

**Table 5: AdaFisher training time per epoch (s) across various numbers of GPUs on ResNet-50 ImageNet.**
| GPU amount | Batch Size | AdaFisher training time per epoch (s) |
| --- | --- | --- |
| 1 | 256 | 2882 |
| 2 | 512 | 1438 |
| 3 | 768 | 963 |
| 4 | 1024 | 720 |

### A.4 Distributed AdaFisher

The efficacy of AdaFisher hinges on its innovative approximation of the FIM, denoted as $\tilde{F}$, which leverages Kronecker factors for computation. In a distributed setting, it is crucial to aggregate these Kronecker factors across multiple GPUs before updating the model parameters. Consider a training environment consisting of $N$ GPUs. For any given layer $i$, the Kronecker factors are computed and aggregated across all GPUs as

$$ $\displaystyle(\mathbf{H}_{D_{i}}^{\prime})^{\text{SUM}}=\frac{1}{N}\sum_{n=1}^ {N}(\mathbf{H}_{D_{i}}^{\prime})^{n},\quad(\mathbf{S}_{D_{i}}^{\prime})^{\text {SUM}}=\frac{1}{N}\sum_{n=1}^{N}(\mathbf{S}_{D_{i}}^{\prime})^{n}$ (18) $$

The theoretical justification for this aggregation lies in the linearity of expectation and the unbiasedness of the local Kronecker factor estimates. Specifically, if each $(\mathbf{H}_{D_{i}}^{\prime})^{n}$ and $(\mathbf{S}_{D_{i}}^{\prime})^{n}$ are unbiased estimators of their respective true factors $\mathbf{H}_{D_{i}}^{\prime}$ and $\mathbf{S}_{D_{i}}^{\prime}$, then the averaged factors $(\mathbf{H}_{D_{i}}^{\prime})^{\text{SUM}}$ and $(\mathbf{S}_{D_{i}}^{\prime})^{\text{SUM}}$ remain unbiased estimators of $\mathbf{H}_{D_{i}}^{\prime}$ and $\mathbf{S}_{D_{i}}^{\prime}$. Consequently, the aggregated EFIM for layer $i$ can be calculated as

$$ $\displaystyle\tilde{F}_{D_{i}}^{\text{SUM}}=(\mathbf{H}_{D_{i}}^{\prime})^{ \text{SUM}}\otimes(\mathbf{S}_{D_{i}}^{\prime})^{\text{SUM}}+\lambda$ $$

where $\lambda$ is a regularization parameter added to ensure numerical stability. This methodology ensures that each GPU contributes to a comprehensive update of the model, enhancing both convergence and performance in large-scale distributed training environments. We assessed the distributed version of AdaFisher on ImageNet, utilizing batch sizes of 512 and 1024 (refer to Table 4.1 and Figure 16 for details). Our findings indicate that AdaFisher scales nearly linearly with the number of GPUs, as evidenced in Table 5. There remains scope for additional low-level optimizations within the implementation to further enhance performance.

## Appendix B Ablation Studies

Building on the ablative studies detailed in Section 4.4, this section extends our stability analysis to explore the impact of various learning rate schedulers and convergence efficiency, as discussed in Section B.1. Additionally, we conduct an in-depth examination of the key components of AdaFisher. This includes analyzing the effects of the EMA, the use of square root transformations, our novel approximation of the FIM, and the critical role of computing the FIM for normalization layers, all of which are detailed in Section B.2. We have consolidated the key findings of each ablation study in Table 6.

**Table 6: Summary of Ablation Studies for AdaFisher Optimizer.**
| Ablation Study | Component Studied | Key Findings |
| --- | --- | --- |
| Learning rate schedulers | Impact of Cosine Annealing, StepLR, and no scheduler on AdaFisher | AdaFisher maintains stable and efficient performance across various schedulers, demonstrating its robustness and adaptability in diverse training environments. For further details please refer to Section B.1. |
| Convergence Efficiencys | Performance and alignment of FIM with Hessian | AdaFisher shows marked performance improvements towards the end of training, with FIM alignment to the Hessian enhancing rapid convergence and stable generalization across training and testing phases. For further details please refer to Section B.1. |
| Square Root Utilization | Effect of omitting square root in update rules | Eliminating the square root enhances AdaFisher’s performance and stability, outperforming both its own version with the square root and Adam without the square root, while also improving computational efficiency. For further details please refer to Section B.2. |
| EMA of Kronecker Factors | Utilization of EMA for curvature estimation | Using EMA on Kronecker factors enhances AdaFisher’s curvature estimation, leveraging data from multiple mini-batches for continuous updates, demonstrating significant benefits in methods with diagonal or block-diagonal curvature approximations. For further details please refer to Section B.2. |
| Importance of Fisher Computation for Normalization Layers | Impact of EFIM in normalization layers | Incorporating Fisher computation in normalization layers significantly improves AdaFisher’s generalization and stability by enhancing parameter sensitivity and gradient variability insights, crucial for optimizing training dynamics and model convergence. For further details please refer to Section B.2. |
| New Approximation of the FIM | Diagonal approximation of the FIM | Our novel method focuses on the diagonal elements of the FIM, enhancing computation efficiency without losing critical information. Validation shows our approximation closely aligns with the true Fisher, confirming its efficacy. For further details please refer to Section B.2. |

Figure: Figure 11: Performance comparison of AdaFisher using the ResNet50 on the CIFAR10 with batch size of 256 with different learning rate schedulers.
Refer to caption: extracted/5936014/images/schedulers.png

Figure: Figure 12: Comparison of FIM Diagonal Histograms during ResNet18 Training on CIFAR10 with Adam and AdaFisher over 1,000 training iterations. Panel (A) displays the FIM diagonal elements for the first convolutional layer; Panel (B) illustrates the FIM diagonal elements for the middle convolutional layer; Panel (C) shows the FIM diagonal elements for the last Linear layer.
Refer to caption: extracted/5936014/images/hist_Fisher_all.jpg

### B.1 Evaluating Stability Across Learning Rate Schedulers, and Assessing Convergence Efficiency

Learning rate schedulers. This analysis evaluates the impact of different learning rate schedulers–Cosine Annealing, StepLR, and no scheduler—on the performance of AdaFisher, as depicted in Figure 11. AdaFisher exhibits remarkable robustness across these scheduling strategies. Notably, its performance remains stable and efficient whether it is paired with the gradual adjustments of Cosine Annealing, the abrupt changes of StepLR, or even in the absence of any scheduler. This underscores AdaFisher’s adaptability and effectiveness in diverse training environments.

Convergence Efficiency. As training progresses, AdaFisher optimizer demonstrates a significant enhancement in performance compared to its counterparts, especially evident towards the end of the training period (see Appendix D.2.4). This rapid convergence is attributed to AdaFisher’s approach by incorporating the FIM. Early and mid-training, the FIM serves as an approximation to the Hessian matrix, equivalent to the Generalized Gauss Newton Matrix (Eschenhagen et al., ). However, as the model approaches a local minimum, the FIM increasingly aligns precisely with the Hessian (Martens, ). This precise alignment accelerates convergence, markedly improving the optimizer’s efficiency in the final phases of training. Additionally, AdaFisher’s tendency to converge to flat local minima leads to more stable generalization when transitioning from training to testing distributions (Cha et al., ), contrasting sharply with other optimizers. To support these points, we analyze the training distribution of our diagonal block-Kronecker FIM during the training of ResNet18 on CIFAR10. Specifically, we examine the FIM distribution for the first (Panel A), middle (Panel B) convolutional layers and the last linear layer (Panel C), as shown in Figure 12. It is evident that for each layer, the FIM distribution with AdaFisher narrows to smaller values with fewer variations compared to that with Adam. This pattern demonstrates AdaFisher’s convergence toward flatter local minima, as the Fisher Information, approximation of the Hessian, containing crucial curvature information.

### B.2 Component Analysis: Evaluating the Significance of AdaFisher’s Elements

AdaFisher incorporates several key components, including a novel approximation of the FIM, the EMA of the Kronecker factors, the omission of the square root in the update rule, and a new EFIM formula for normalization layers. In this part, we elucidate each component and its significance within the AdaFisher optimizer.

Square Root Utilization. Recent studies, such as (Lin et al., ), have reevaluated the necessity of the square root operation in the Adam family’s update rules. These studies suggest that eliminating the square root does not affect convergence and may even narrow the generalization gap compared to SGD in CNN models. Our analysis, shown in panel (A) of Figure 13, investigates this aspect by comparing the performance of AdaFisher and Adam, both with and without the square root operation. The findings reveal that removing the square root not only boosts the performance and stability of both optimizers but also significantly enhances computational efficiency. Specifically, AdaFisher without the square root not only outperforms the version with the square root but also surpasses Adam without the square root. However, Adam without the square root typically requires an additional scaling factor proportional to the batch size, denoted as $f\propto\text{batch size}$, to function correctly. Without this factor, Adam without the square root fails to learn effectively, making direct comparisons with AdaFisher invalid.

EMA of Kronecker Factors. As elucidated in Section 3.2, employing an EMA over the Kronecker factors facilitates a more sophisticated curvature estimation. This technique leverages data across multiple mini-batches, enabling continuous updates to the Fisher information rather than relying solely on the data from a single batch. Panel (B) of Figure 13 underscores, using ResNet-50 on CIFAR10 over 200 epochs, the benefits of using EMA on Kronecker factors, a strategy particularly advantageous in methods that utilize diagonal or block-diagonal approximations of the curvature matrix.

Importance of Fisher Computation for Normalization Layers. The integration of the EFIM in normalization layers, as detailed in Proposition 3.1, significantly enhances the generalization process. Panel (C) of Figure 13 illustrates the impact of incorporating Fisher computation in these layers during the training of AdaFisher with ResNet-50 on CIFAR10 over 200 epochs. In contrast, the identity matrix is employed when Fisher computation is omitted. The superior performance of AdaFisher when incorporating Fisher computation can be attributed to the critical role normalization layers play in adjusting the input distribution for each mini-batch. This adjustment substantially enhances the neural network’s learning stability (Jiang et al., ). By quantifying the information each output $y$ carries about the parameters $\theta$ under the model distribution $p(y\mid x;\theta)$, the computation of the FIM in these layers provides valuable insights into parameter sensitivity and gradient variability. This insight is crucial for optimizing training dynamics and enhancing model convergence—areas that are often inadequately addressed by existing optimizers.

New Approximation of the FIM.
In Proposition 3.2, we introduce a new methodology for approximating the FIM that diverges from the K-FAC optimizer. Unlike K-FAC, which utilizes the full Kronecker product, our approach focuses solely on the diagonal elements of the FIM, where, as demonstrated in Section 3.1, the energy of the Kronecker factors is predominantly concentrated. This method enables a more efficient computation of the FIM without sacrificing critical information. To validate our approach, we compare the true FIM diagonal with our approximation in convolutional and dense layers using a toy model composed of 2 convolutional layers and 2 linear layers on a subset of the MNIST dataset (Deng, ) over 50 epochs. Specifically, we calculate the true Fisher using the NNgeometry Python package (George, ), which facilitates the computation of the FIM, Gauss-Newton Matrix, or Neural Tangent Kernels applied to neural networks. We estimate $p(y\mid x)$ through Monte-Carlo sampling. During each epoch, we collected both the empirical and true Fisher information and calculated the Mean Absolute Error (MAE) between these two measures. Panel (D) of Figure 13 showcases the close approximation of AdaFisher’s empirical diagonal to the true Fisher, thus validating the efficacy of our approximation method.

Figure: Figure 13: AdaFisher Component Analysis. (A) Comparison of MAE between the true FIM $F_{D}$ and our approximation $\tilde{F}_{D}$ across convolutional and dense layers. (B) Performance comparison of AdaFisher with and without the EMA of Kronecker factors. (C) Assessment of AdaFisher’s performance with and without the computation of EFIM for Batch Normalization (BN) layers.
Refer to caption: extracted/5936014/images/AdaFisher_elemts.jpg

## Appendix C Visualization

The convergence rate of an optimizer is crucial, serving as an indicator of its robustness against saddle points and its ability to generalize effectively. In this section, we introduce a novel methodology for visualizing the convergence behavior of optimizers through a statistical model, as depicted in Figure 1. Initially, our process employs Principal Component Analysis (PCA) for dimensionality reduction, reducing the dataset dimensions from $\mathcal{D}\in\mathbb{R}^{m\times n}$ to $\hat{\mathcal{D}}\in\mathbb{R}^{m\times 2}$, following the protocol established in F.R.S. (). We then apply this reduced dataset to a toy model composed of an $L$-layer multi-layer perceptron (MLP). Notably, we focus on the first weight matrix $W_{1}^{e}$ of this MLP, which resides in $\mathbb{R}^{2}$, where $e$ denotes the epoch number. For consistency and to ensure comparability, all layers’ weights are initialized identically across different optimizers.

Figure: Figure 14: Pipeline for visualization of optimization paths for various algorithms on a loss surface, comparing their convergence efficiency.
Refer to caption: extracted/5936014/images/Pipeline.png

Following the training phase with various optimizers where we denote a set of optimizer results $\mathcal{O}$, we analyze both the collection of first-layer weights, $\mathcal{W}$, and the evolution of the loss function, $\mathfrak{L}$ defined as:

$$ $\mathcal{W}=\begin{bmatrix}(W_{1}^{1})^{\top}\\ (W_{1}^{2})^{\top}\\ \vdots\\ (W_{1}^{E})^{\top}\end{bmatrix},\quad\mathfrak{L}=[\mathcal{L}_{1}^{1}, \mathcal{L}_{1}^{2},\ldots,\mathcal{L}_{1}^{E}]^{\top}$ $$

where $(W_{1}^{e})^{\top}$ represents the weight vector at the $e$-th epoch, and $\mathcal{L}_{1}^{e}$ represents the loss at the $e$-th epoch, extracted from the optimization results $\mathcal{O}$. We construct a grid $(\mathbf{X},\mathbf{Y})$ spanning the range of weight parameters, discretized into $200$ linearly spaced points along each axis:

$$ $\mathbf{X},\mathbf{Y}=\text{meshgrid}\left(\min(\mathcal{W}_{:,1}),\max( \mathcal{W}_{:,1}),\min(\mathcal{W}_{:,2}),\max(\mathcal{W}_{:,2}),200\right)$ $$

Finally, we interpolate the loss values $\mathcal{L}$ over the grid using cubic interpolation to obtain a smooth loss surface $\mathbf{Z}$:

$$ $\mathbf{Z}=\text{griddata}(\mathcal{W},\mathcal{L},(\mathbf{X},\mathbf{Y}), \text{method}=^{\prime}cubic^{\prime})$ $$

These elements are integral to the visualization process, which elucidates the optimizer’s trajectory through the parameter space across training epochs. It is important to note that while we focus on the first layer’s weight matrix for clarity, the methodology can be adapted to visualize the weights of any layer within the network. Figure 14 summarizes the pipeline.

In the experiment depicted in Figure 1, we selected the IRIS dataset (rz7, ), owing to its widespread recognition and compatibility with PCA application. Our model employs a 2-layer MLP architecture. We specifically attend to the weight matrix of the first layer, denoted by $W_{1}\in\mathbb{R}^{2}$. This particular focus is informed by the empirical observation that the parameters of the first layer tend to exhibit a faster convergence rate compared to those of subsequent layers in the network. Such a phenomenon can be attributed to the more direct influence of the input features on the first layer’s weights, which often results in a more pronounced and expedited learning dynamic. Given the classification nature of the task, we employed the Cross-Entropy loss function (Zhang & Sabuncu, ). The network was trained over 20 epochs using a suite of optimizers: Adam, AdaHessian, K-FAC, Shampoo, and AdaFisher. We standardized the learning rate across all optimizers at $1\times 10^{-3}$ to ensure comparability of results. Examination of Figure 1 reveals that AdaFisher’s convergence is markedly superior to that of its counterparts, achieving rapid convergence to the local minimum of the loss landscape concerning the first weight parameter within a few iterations. Conversely, the alternative optimizers demonstrate convergence to less optimal local minima.

## Appendix D Experiments

### D.1 Hardware

In total, we had a server with 6 NVIDIA RTX 6000 Ada Generation GPUS with 48 gigabytes of VRAM, and 128 gigabytes of RAM available for all experiments. All experiments described in this report were conducted on a system equipped with a single NVIDIA RTX 6000 Ada Generation GPU and 64 gigabytes of RAM, except for training AdaFisher on ImageNet with batch sizes of 512 and 1024, where four GPUs were utilized.

### D.2 Image Classification

We provide further results and detailed descriptions of our image classification experiments in this section. We conducted five trials with random initializations for the CIFAR experiments, and one trial each for Tiny ImageNet and ImageNet. We present the mean and standard deviation of the results for these trials.
Note on training time. Given that various optimizers demonstrate significantly different epoch durations, we have standardized our comparisons by restricting training to the total WCT consumed by 200 epochs using AdaFisher for both CIFAR and Tiny ImageNet experiments. Conversely, for ImageNet, we report the results based on 90 WCT training epochs using Adam, as, surprisingly, AdaFisher and Adam exhibited the same duration in this experiment. The final selected number of epochs for each optimizer is detailed in Table 7. Please note that we were unable to train AdaHessian on ImageNet due to the significant computational resources required by this optimizer.

**Table 7: Comparison of the final epoch counts for various optimizers across different datasets.**
|  | CIFAR10/100 & Tiny ImageNet | ImageNet |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Optimizers | Adam/AdamW | AdaHessian | K-FAC | Shampoo | AdaFisher/AdaFisherW | Adam | K-FAC | Shampoo | AdaFisher |
| Epochs | 210 | 89 | 107 | 36 | 200 | 90 | 60 | 26 | 90 |

#### D.2.1 Hyperparameter Tuning

Effective hyperparameter tuning is crucial for optimizing the performance of deep learning models. In this study, we systematically explored various hyperparameters for both CNNs and ViTs across multiple image classification tasks. The following subsections detail the tuning strategies employed for each model architecture and dataset.

CNNs.
For all image classification tasks involving CNNs, we utilized ResNet18 as the backbone architecture and evaluated its performance on the CIFAR-10 dataset with a fixed batch size of 256. The hyperparameter tuning process encompassed the following components:

- •
Optimizer Selection and Learning Rate Tuning:
Each optimizer was fine-tuned using ResNet18 on CIFAR-10. We performed a grid search to identify the optimal learning rate from the set $\{0.0001,0.0003,0.0005,0.0009,\dots,0.1,0.3,0.5,0.9\}$.
- •
Learning Rate Scheduling:
A cosine annealing learning rate decay strategy was employed, aligning with the number of training epochs specified for each optimizer in Table 7. This approach follows the methodology proposed by Loshchilov & Hutter () and was determined to be optimal for our experimental setup.
- •
Weight Decay:
We applied a uniform weight decay of $5\times 10^{-4}$ across all optimizers for CIFAR-10 and Tiny ImageNet. An exception was made for MobileNetV3, where the weight decay was set to $1\times 10^{-5}$. For experiments on ImageNet, the weight decay was established at $1\times 10^{-4}$.
- •
Damping Parameter Tuning:
–
AdaFisher, K-FAC, and Shampoo:
*
K-FAC and AdaFisher: The damping parameter was searched within $\{0.0001,0.0003,0.0005,0.0009,0.001,0.003,0.005,0.009,0.01,0.03,0.05,0.09\}$. This range was chosen based on prior research (Martens & Grosse, ) and our own experiments, which indicated optimal damping values around $1\times 10^{-3}$.
*
Shampoo: The damping parameter was tuned within $\{1\times 10^{-6},3\times 10^{-6},5\times 10^{-6},9\times 10^{-6},1\times 10^{
-5},3\times 10^{-5},5\times 10^{-5},9\times 10^{-5},1\times 10^{-4},3\times 10
^{-4},5\times 10^{-4},9\times 10^{-4}\}$, as optimal values typically reside around $1\times 10^{-5}$.
–
AdaHessian:
The Hessian power was tuned within the range $\{0.1,0.2,\dots,0.9,1.0\}$.
–
AdaFisher Decay Factors:
The decay factors $\gamma_{1}$ and $\gamma_{2}$ for AdaFisher were tuned within $\{0.1,0.2,\dots,0.9,0.99\}$.
- •
Implementation Details:
For the Shampoo and K-FAC optimizers, we utilized the ASDL library as implemented in PyTorch provided by Osawa et al. ().

ViTs.
For ViT-based image classification tasks, we employed the Tiny Swin Transformer on the CIFAR-10 dataset with a batch size of 256. The hyperparameter tuning strategy for ViTs included the following elements:

- •
Weight Decay:
Weight decay values were set as indicated in the respective original publications for each model:
–
Tiny Swin: $1\times 10^{-2}$
–
FocalNet: $5\times 10^{-2}$
–
CCT-2/3$\times$2: $6\times 10^{-2}$
- •
Learning Rate Tuning:
For AdaFisher, AdaHessian, K-FAC, and Shampoo optimizers, we conducted a grid search over the learning rates $\{0.3,0.15,0.1,0.05,0.03,0.015,0.01,0.005,0.003,0.0015,0.001\}$, as these optimizers typically operate with higher learning rates compared to Adam-based optimizers. For AdamW, the learning rates were adopted from the original publications:
–
Tiny Swin and FocalNet: $1\times 10^{-4}$
–
CCT-2/3$\times$2: $5.5\times 10^{-5}$
- •
Damping Parameter Tunning:
We performed the same grid search over the damping parameter for K-FAC, Shampoo and AdaFisher, the Hessian power for AdaHessian and the decay factors for AdaFisher as explained in the CNNs part.

This meticulous hyperparameter tuning process ensures that each optimizer is optimally configured for the respective model architectures and datasets, thereby facilitating a fair and comprehensive comparison of their performance across different image classification tasks. The final learning rates for all optimizers and models are detailed in Table 8.

**Table 8: Final selected learning rates for each optimizer, tuned using ResNet18 (for CNN) and Tiny Swin (for ViT) on CIFAR10 using a batch size of 256. We selected based on final validation top-1 accuracy.**
| Architecture | Adam | AdamW | AdaHessian | K-FAC | Shampoo | AdaFisher | AdaFisherW |
| --- | --- | --- | --- | --- | --- | --- | --- |
| CNNs | 0.001 | - | 0.15 | 0.3 | 0.3 | 0.001 | - |
| ViTs | - | 0.0001/0.000055 | 0.01 | 0.003 | 0.003 | - | 0.001 |

#### D.2.2 Dataset Details

CIFAR. The training/test sets for Cifar10/100 dataset contain 50k/10k images, respectively. We consider a batch size of 256. For CIFAR-related experiments, we perform $32\times 32$ random-resize cropping, random horizontal flipping and cutout (DeVries & Taylor, ) as data augmentations. Please refer to Takahashi et al. () for more details.
Tiny ImageNet. The training/test sets for TinyImageNet Le & Yang () contains 100k/10k images. We perform $64\times 64$ random-resize cropping and random horizontal flipping. The batch size is set to be 256.
ImageNet. The training/test sets for ImageNet Russakovsky et al. () contains 1,281,167/150k images. We consider a batch size of 256, as we performed experiments on a single GPU instance without any GPU parallelism. We follow He et al. () and perform random resized cropping to $224\times 244$ and random horizontal flipping on the train set and $256\times 256$ resizing with $224\times 224$ center cropping on the test set.

#### D.2.3 Transfer Learning

Weights are initialized to the values provided by the publicly available checkpoints by PyTorch, except the first convolutional for the ResNet architecture and last dense layers for all networks, which change size to accomodate the new kernel size and number of classes respectively, that are randomly initialized. We train all models with weight decay $1e^{-4}$ as suggested in Wightman et al. (), expect for MobileNetV3 where weight decay is set to be $1e^{-5}$. Moreover, we did a grid search for each optimizer for selecting the best learning rate of the range $\{0.3,0.15,0.1,0.03,0.015,0.01,\dots,1e-5\}$ where we tabulate the selected learning rate for each optimizer in Table 9. We use a batch size of 256 and cosine learning rate decay. We use the same augmentation policy (without Cutout) as in the previous experiments. The results were obtained using the WCT technique over 50 training epochs of AdaFisher, with the final epoch count detailed in Table 10. All other parameters remained unchanged.

**Table 9: Final selected learning rates for each optimizer with ImageNet-1k pretrained weights, tuned using ResNet50 on CIFAR10 using a batch size of 256. We tuned by completing a full WCT epoch training cycle, and selected based on final validation top-1 accuracy.**
| Adam | AdaHessian | K-FAC | Shampoo | AdaFisher |
| --- | --- | --- | --- | --- |
| 0.0001 | 0.15 | 0.3 | 0.03 | 0.001 |

**Table 10: Final selected epoch counts for various optimizers across transfer learning task.**
| Adam/AdamW | AdaHessian | K-FAC | Shampoo | AdaFisher/AdaFisherW |
| --- | --- | --- | --- | --- |
| 55 | 22 | 27 | 18 | 50 |

**Table 11: Performance metrics (mean, std) of different networks and optimizers on CIFAR10 and CIFAR100 using batch size 256 (a) without Cutout and (b) with Cutout. Reported using WCT of 200 AdaFisher training epochs as the cutoff.**
|  | CIFAR10 | CIFAR100 |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Network | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher |
| ResNet18 | $93.64_{0.02}$ | $94.05_{0.08}$ | $94.04_{0.16}$ | $94.52_{0.12}$ | $\mathbf{95.02_{0.11}}$ | $72.71_{0.24}$ | $73.64_{0.21}$ | $74.79_{0.19}$ | $76.53_{0.11}$ | $\mathbf{77.10_{0.21}}$ |
| ResNet50 | $93.89_{019}$ | $94.26_{0.11}$ | $94.25_{0.08}$ | $94.92_{0.09}$ | $\mathbf{95.42_{0.21}}$ | $73.12_{0.73}$ | $75.29_{0.31}$ | $75.49_{0.17}$ | $77.81_{0.22}$ | $\mathbf{78.91_{0.91}}$ |
| ResNet101 | $93.14_{0.12}$ | $94.73_{0.85}$ | $94.23_{0.13}$ | $94.22_{0.04}$ | $\mathbf{95.51_{0.13}}$ | $73.23_{0.37}$ | $72.19_{0.23}$ | $75.46_{0.26}$ | $78.82_{0.11}$ | $\mathbf{79.74_{0.28}}$ |
| DenseNet121 | $93.74_{0.16}$ | $94.54_{0.08}$ | $94.97_{0.05}$ | $94.99_{0.10}$ | $\mathbf{95.29_{0.06}}$ | $75.38_{0.34}$ | $72.54_{0.89}$ | $77.09_{0.26}$ | $78.70_{0.27}$ | $\mathbf{79.03_{0.17}}$ |
| MobileNetV3 | $91.95_{0.115}$ | $91.4_{3.06}$ | $91.92_{0.14}$ | $91.91_{0.19}$ | $\mathbf{92.89_{0.11}}$ | $65.64_{0.19}$ | $60.78_{3.61}$ | $69.87_{0.262}$ | $68.01_{0.24}$ | $\mathbf{73.15_{0.24}}$ |
| Tiny Swin | $87.47_{0.16}$ | $78.34_{0.23}$ | $66.84_{0.25}$ | $68.44_{0.17}$ | $\mathbf{89.08}_{0.11}$ | $62.20_{0.22}$ | $54.12_{0.25}$ | $36.12_{0.28}$ | $33.75_{0.27}$ | $\mathbf{66.47_{0.19}}$ |
| FocalNet | $85.65_{0.12}$ | $71.03_{0.25}$ | $42.92_{0.18}$ | $41.49_{0.23}$ | $\mathbf{86.92}_{0.14}$ | $52.88_{0.25}$ | $38.05_{0.28}$ | $11.23_{0.31}$ | $11.06_{0.32}$ | $\mathbf{52.9_{0.13}}$ |
| CCT-2/3$\times$2 | $83.95_{0.12}$ | $-$ | $34.63_{1.03}$ | $35.1_{0.78}$ | $\mathbf{84.63_{0.25}}$ | $60.14_{1.06}$ | $-$ | $8.06_{0.59}$ | $9.76_{0.28}$ | $\mathbf{60.63_{0.65}}$ |

#### D.2.4 Results

Table 12 displays the results for the Tiny ImageNet dataset using ResNet50 and Big Swin networks, with visualizations provided in Figure 15. AdaFisher and AdaFisherW consistently outperform current SOTA optimizers. Notably, Figure 15 illustrates that although AdaFisher converges slower than K-FAC during ResNet50 training, it achieves superior generalization. This is evidenced by lower testing errors, suggesting that AdaFisher tends to converge to a flatter local minimum, enabling smoother transitions between training and testing datasets with minimal generalization loss. For further explanation, please see Cha et al. (). Please note that due to AdaHessian’s high memory consumption, we were unable to train it on Big Swin.

Table 11 presents the performance of various networks on CIFAR10/100 datasets using different optimizers, both with and without the cutout augmentation technique. AdaFisher and AdaFisherW consistently outperform their counterparts in both scenarios, demonstrating stable training and robustness to the augmentation techniques. The training losses and test errors for the CIFAR experiments, both with and without cutout, are visually represented in Figures 17, 18, 19, and 20.

**Table 12: Performance of various networks and optimizers on TinyImegneNet using batch size 256. Reported using wall clock time of 200 AdaFisher training epochs as the cutoff.**
| Network | Adam | AdaHessian | K-FAC | Shampoo | AdaFisher |
| --- | --- | --- | --- | --- | --- |
| ResNet50 | $53.06$ | $50.21$ | $50.05$ | $53.53$ | $\mathbf{57.41}$ |
| Big Swin | $48.11$ | $-$ | $8.89$ | $4.11$ | $\mathbf{48.86}$ |

Figure: Figure 15: WCT training loss and testing error curves of several optimizers on Tiny ImageNet dataset, ResNet-50 and Big Swin with batch size of 256. AdaFisher consistently achieves lower test error as compared to Adam, AdaHessian, K-FAC and Shampoo. The final accuracy results are reported in Table 12.
Refer to caption: extracted/5936014/images/results_TinyImageNet.png

Figure 16 illustrates the training and validation error of the distributed version of AdaFisher on ImageNet across various batch sizes. AdaFisher not only outperforms its counterparts with smaller batch sizes (256), but it also continues to achieve superior generalization as batch sizes increase. Furthermore, these results reinforce the stability analysis concerning batch sizes presented in Section 4.4, extending it to a more challenging dataset.

Figure: Figure 16: Performance of distributed AdaFisher using ResNet50 on ImageNet with different batch sizes for 90 epochs. The final accuracy results are reported in Table 4.1.
Refer to caption: extracted/5936014/images/imageNet_distributed.png

Figure: Figure 17: WCT training loss, test error, for CNNs and ViTs on CIFAR10 experiments, without Cutout. A batch size of 256 was used and all networks were tuned using ResNet18 applied on CIFAR10. The final accuracy results are reported in Table 11 (a).
Refer to caption: extracted/5936014/images/results_Cifar10_nocutout.png

Figure: Figure 18: WCT training loss, test error, for CNNs and ViTs on CIFAR100 experiments, without Cutout. A batch size of 256 was used and all networks were tuned using ResNet18 applied on CIFAR10. The final accuracy results are reported in Table 11 (a).
Refer to caption: extracted/5936014/images/results_Cifar100_nocutout.png

Figure: Figure 19: WCT training loss, test error, for CNNs and ViTs on CIFAR10 experiments, with Cutout. A batch size of 256 was used and all networks were tuned using ResNet18 applied on CIFAR10. The final accuracy results are reported in Table 11 (b).
Refer to caption: extracted/5936014/images/results_cifar10_cutout.jpg

Figure: Figure 20: WCT training loss, test error, for CNNs and ViTs on CIFAR100 experiments, with Cutout. A batch size of 256 was used and all networks were tuned using ResNet18 applied on CIFAR10. The final accuracy results are reported in Table 11 (b).
Refer to caption: extracted/5936014/images/results_cifar100_cutout.png

Figure: Figure 21: WCT training loss, test error, for CNNs on CIFAR10/100 experiments. A batch size of 256 was used and all networks were tuned using ResNet50 applied on CIFAR10. The final accuracy results are reported in Table 3.
Refer to caption: extracted/5936014/images/results_pretrained.png

#### D.2.5 Comparison of Training Speed and Memory Utilization

As discussed in Section 4.4, AdaFisher emerges as a balanced trade-off between time complexity and performance. Similarly, its memory footprint is comparable to that of Adam, showcasing efficient VRAM utilization. We extend our stability analysis to the CIFAR-10 dataset to provide a dataset-independent evaluation of performance metrics, as depicted in Figure 22. Additionally, we analyze the memory usage for different batch sizes using the ResNet-50 model on the CIFAR-10/100, presented in Figure 23. The analysis reveals that AdaFisher, while maintaining high accuracy levels, uses memory comparably to Adam, especially evident in higher batch sizes. This suggests that AdaFisher can achieve competitive performance without excessive VRAM consumption, making it an optimal choice for scenarios with memory constraints.

Figure: Figure 22: Performance comparison of AdaFisher and other optimizers across various batch sizes, epoch times and learning rate (with batch size of 256), evaluated using the ResNet50 on the CIFAR-10.
Refer to caption: extracted/5936014/images/batch_stability.png

Figure: Figure 23: Performance comparison of AdaFisher and other optimizer regarding the memory used, assessed using ResNet50 and CIFAR10/100 across different batch sizes. This figure highlights how AdaFisher competes closely with Adam in terms of memory efficiency and performance.
Refer to caption: extracted/5936014/images/mem_used.png

Epoch Times. Continuing our analysis of the time complexity for each optimizer, we present in Figure 24 the epoch times for various network architectures and datasets. Specifically, we compare the epoch times of Adam, AdaFisher, K-FAC, AdaHessian, and Shampoo optimizers on CIFAR10 and CIFAR100 datasets. As depicted in Figure 24 panel (A), AdaFisher demonstrates a comparable training time to Adam across multiple network architectures on the CIFAR10 dataset. This indicates that AdaFisher achieves efficient optimization without incurring significant additional computational cost. Similarly, in Figure 24 panel (B), we observe that the epoch times for AdaFisher remain close to those of Adam on the CIFAR100 dataset. While K-FAC and AdaHessian exhibit increased training times, Shampoo shows the highest epoch times across all tested networks. This further highlights the efficiency of AdaFisher as an optimizer, combining the advantages of advanced optimization techniques with practical training times.

Figure: Figure 24: Epoch times for various networks on CIFAR10 (A) and CIFAR100 (B) using Adam, AdaFisher, K-FAC, AdaHessian and Shampoo.
Refer to caption: extracted/5936014/images/bar_plot_time.png

### D.3 Language Modelling

#### D.3.1 Dataset Details

The Wikitext-2 dataset, derived from high-quality Wikipedia articles, contains over two million words and is structured into training, validation, and test sets. It is widely used for benchmarking language models in natural language processing, especially assessing perplexity to evaluate predictive performance. This dataset offers a balance between computational efficiency and linguistic complexity, making it ideal for practical language model training and evaluation.

#### D.3.2 Network Details

Network. We utilize a streamlined GPT-1 architecture which incorporates four self-attention layers, a reduction from the original twelve. This configuration retains core modeling capabilities while reducing complexity, encompassing a total of 28,351,488 learnable parameters.
Embeddings & Parameter Sharing. To expedite training, we employ pretrained embeddings from OpenAI’s GPT, leveraging the benefits of parameter sharing for enhanced efficiency and faster convergence.

#### D.3.3 Hyperparameters

The model underwent training for 50 WCT epochs using AdaFisher on the WikiText-2 and PTB datasets, with the final epoch counts for each optimizer detailed in Table 13.

**Table 13: Final selected epoch counts for various optimizers across language modelling task**
| AdamW | AdaHessian | Shampoo | AdaFisherW |
| --- | --- | --- | --- |
| 55 | 18 | 12 | 50 |

For AdamW, we follow the learning rate setting in ElNokrashy et al. (). For the other optimizers we select the learning rate by doing a grid search of $\{0.3,0.15,0.1,0.05,0.03,0.015,0.01,\dots,1e^{-5}\}$. We tabulate the learning rate the we use in Table 14. The batch size was configured to 32, and the weight decay was established at $0.1$. Despite optimizing the configuration of hyperparameters, Shampoo failed to converge, and K-FAC could not be trained at all.

**Table 14: Final selected learning rates for each optimizer, tuned using GPT1 on WikiText-2 and PTB using a batch size of 32. We selected based on final validation PPL.**
| AdamW | AdaHessian | Shampoo | AdaFisherW |
| --- | --- | --- | --- |
| $5e^{-5}$ | $0.015$ | $0.003$ | $1e{-4}$ |

#### D.3.4 Results

Figure 25 displays the training loss and testing error curves, clearly showing that AdaFisher surpasses both Adam and AdaHessian in performance on the WikiText-2 and PTB datasets.

Figure: Figure 25: Training Loss and Test Perplexity of Small GPT-1 Model on WikiText-2 and PTB Datasets. Experiments were conducted using a batch size of 32 and optimal settings for all optimizers.
Refer to caption: extracted/5936014/images/test_train_losses_LM.png

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Does your shampoo baseline use grafting? 
CASPR is another paper which uses Kronecker sum based approach, what are your thoughts on Kronecker sum based combination to approximate empirical Fisher information matrix.
soundness: 3
strengths: 1. Kronecker factored preconditioner with diagonal factors hasn't been used with empirical Fisher matrix before. 
2. Thorough experimentation.
summary: The paper proposes a new idea: using Kronecker factored preconditioners, with diagonal factors. The Kronecker product approximates empirical Fisher information matrix. The method demonstrates better performance compared to diagonal approaches such as Adam.
weaknesses: 1. The preconditioner still requires layer inputs and gradients backpropaged through the layer, which is not always feasible for large training systems. 
2. The Adafactor already uses Kronecker factored preconditioner with diagonal factors. There is no comparison against Adafactor. 
3. sub-optimal regret bound $O(\log(T)\sqrt{T})$, compared to Shampoo - which is optimal $O(\sqrt{T})$.
4. There are low rank approaches with similar complexity as proposed methods  such as EVA [1]. There should be comparison against EVA.

If 2, 3, and 4 are addressed, I am willing to increase my score.

[1] Zhang, Lin, Shaohuai Shi, and Bo Li. "Eva: Practical Second-order Optimization with Kronecker-vectorized Approximation." The Eleventh International Conference on Learning Representations. 2022.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 2
questions: 1. The authors should specify the difference of the current work to the previous work "Kronecker-Factored Second-Order Optimizers Perform First-Order Descent on Neurons" by Frederik Benzing.

2. Empirically, the high-order optimizers are computationally more expensive than first order optimizers for each step and also have poorer generalizability. It is somehow strange that the numerical results in this work didn't show how the method accelerate the training process clearly but mainly about the strength of the method in generalization. The authors should explain why the method can help in enhance the generalization significantly. They should also include results obtained with SGD, since usually the generalization ability  of SGD is better than ADAM.
soundness: 2
strengths: Using the Fisher imformation matrix as a precondition is really a good point.
summary: The authors use the Fisher information matrix as a precondition matrix to obtain a second order optimizer. They also provided some analysis and numerical results for the method. 

My concern is that this method is too similar to a previous method "Kronecker-Factored Second-Order Optimizers Perform First-Order Descent on Neurons" by Frederik Benzing.
weaknesses: It seems that the author didn't realize a previous work "Kronecker-Factored Second-Order Optimizers Perform First-Order Descent on Neurons" by Frederik Benzing, which is very similar to this work.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 3
questions: - In Section  2,  it  is  stated  that  $F_i = \cal{H_{i-1}} \otimes \cal{S_{i}}$, but  in  the  algorithm  implementation,  it  becomes  $F_i = \cal{H_{i}} \otimes \cal{S_{i}}$. Why  is  this  the  case?
- Why are two parameters, $\gamma_1$ and $\gamma_2$, introduced for calculating the exponential moving averages of $\cal{H}$ and $\cal{S}$ in the AdaFisher optimizer? Would it not suffice to introduce only one parameter?
- It is known that the SGD optimizer performs better than the Adam optimizer in image classification tasks. Why is there no comparison with SGD?
- The experimental section compares performance under the same computation time. Could you provide a performance comparison under the same number of epochs? I suspect that second-order optimizers like AdaHessian may not have converged yet. When all optimizers have converged, does AdaFisher still outperform other second-order optimizers?
- The AdaFisher optimizer introduces two parameters, $\gamma_1$ and $\gamma_2$. I see that the authors conducted extensive searches for these parameters. Could you provide the values of $\gamma_1$ and $\gamma_2$ used in different tasks for the AdaFisher optimizer? If these parameters also require extensive searching to achieve good performance, then the AdaFisher optimizer might be very limited.

I'm willing to improve my score if you address my concerns.
soundness: 3
strengths: The  paper  innovatively  discovers  that  the  Kronecker  factor  is  diagonally  dominant  and  proposes  a diagonal  block-Kronecker  approximation  for  the  FIM. The  resulting  AdaFisher  optimizer  shows  good  performance.  And the  paper  is  well-organized  and  easy to follow.
summary: This  paper  proposes  a new  second-order  optimizer,  AdaFisher,  which  ensures  better  convergence  while  maintaining  computational  efficiency.  Based  on  the  K-FAC optimizer,  AdaFisher  discovers  that  the  Kronecker  factor  is  diagonally  dominant  and  the  Fisher  information  matrix can be approximated  by  using  a diagonal block Kronecker approximation.  On image  classification  and  language  modeling  tasks,  AdaFisher  achieves  better  results  than  other  second-order  optimization  methods when applying Wall-Clock-Time method (training  for  the  same  amount  of  time).
weaknesses: Please  refer  to  Questions.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1.	**Figure 1:**  I try reproducing Figure 1 using your code. In my experiments, AdaFisher did not consistently converge to similar local minima across multiple runs. Could you discuss the sensitivity to initialization or provide further insights?

2.	**Algorithm 1:** How did you choose the values for $\gamma_1$ and $\gamma_2$? You mentioned that “the decay factors $\gamma_1$ and $\gamma_2$ for AdaFisher were tuned within $\(\{0.1, 0.2, \dots, 0.9, 0.99\}\)$, but you did not specify which values were  used. Providing these details would help practitioners apply AdaFisher effectively.

3.	**Related work:** The paper does not mention some other recent second-order optimizers (e.g., Sophia, INNA, etc.), which could be relevant in the context of adaptive second-order methods. Including these in the discussion would provide a more comprehensive overview of related work. 

4.	**Table 3:** I was surprised by the Top-1 accuracy of Adam for ResNet50 on ImageNet. Could you clarify which hyperparameters were used for Adam in this experiment?
soundness: 3
strengths: 1. **Novel methodology:** The introduction of a diagonal block-Kronecker approximation applicable to various layers offers an interesting balance between computational efficiency and the use of curvature information typically employed in second-order optimization. 

2. **Empirical results:** The paper provides comprehensive experimental evidence showing that AdaFisher outperforms baseline methods (Adam, K-FAC, AdaHessian, etc.) on benchmark datasets such as CIFAR-10, CIFAR-100, ImageNet, and WikiText-2 across different network architectures.

3. **Stability:** AdaFisher shows strong stability across varying learning rates and batch sizes, reducing the need for extensive hyperparameter tuning, which is a common challenge when training deep models.

4. **Theoretical contribution:** The paper presents a rigorous theoretical convergence analysis for both convex and non-convex cases, asserting a convergence rate of  $O(\log T / \sqrt{T})$ , similar to Adam-type methods. The derivation of the update rules using the diagonal approximation of the FIM is clearly explained.
summary: The authors introduce **AdaFisher**, a novel adaptive second-order optimizer that uses a block-diagonal approximation of the Fisher Information Matrix (FIM) to improve both convergence speed and computational efficiency in second-order optimization. The paper aims to address the limitations of current second-order methods, such as high computational costs and poor generalization, by proposing a diagonal block-Kronecker approximation of the FIM. The authors demonstrate that AdaFisher outperforms several SOTA optimizers on tasks such as image classification and language modeling.
weaknesses: 1. The paper considers nonconvex optimization, but in reality DNNs are **nonsmooth**, due to operations such as ReLU and max-pooling. It would be valuable to discuss this limitation in Section 3.4. 

2. **Hyperparameter tuning:** It is unclear how many epochs were used for hyperparameter tuning, especially in grid search experiments (Appendix D). Providing more details on the tuning process would enhance the reproducibility of the results.

3. **Comparision with AdamW:** AdamW has become the most widely used optimizer due to its improved handling of weight decay. It would have been interesting to compare AdamW directly with AdaFisherW. (in particular, for image classification).

Meta-review: This paper proposes AdaFisher, a new adaptive second-order optimization method, which offers a strong balance between convergence efficiency and computational feasibility. The authors introduce a novel diagonal block-Kronecker approximation to the Fisher Information Matrix (FIM) for preconditioning gradients, making second-order methods more practical for deep neural network training. One of the key strengths is the robustness of AdaFisher across different tasks, including image classification and language modeling, as well as its ability to outperform state-of-the-art optimizers like Adam and K-FAC in terms of accuracy and convergence speed. The paper also provides a solid theoretical foundation, demonstrating convergence analysis for both convex and non-convex cases, which is a valuable contribution to the field of second-order optimization.

The empirical results are thorough and demonstrate clear improvements over baseline optimizers. The experiments are well-structured, showing that AdaFisher achieves better generalization and stability across a range of hyperparameters, which reduces the effort needed for tuning. Notably, the method is shown to perform well under both wall-clock time comparisons and fixed-epoch evaluations. Additionally, the authors have addressed concerns during the discussion phase effectively, clarifying the novelty compared to related works and providing further comparisons with optimizers like EVA and AdaFactor. Overall, this work presents meaningful advancements in optimization strategies for deep learning.

Decision: Accept (Poster)