Thermodynamic Natural Gradient Descent

## Abstract

Abstract Second-order training methods have better convergence properties than gradient descent but are rarely used in practice for large-scale training due to their computational overhead. This can be viewed as a hardware limitation (imposed by digital computers). Here we show that natural gradient descent (NGD), a second-order method, can have a similar computational complexity per iteration to a first-order method, when employing appropriate hardware. We present a new hybrid digital-analog algorithm for training neural networks that is equivalent to NGD in a certain parameter regime but avoids prohibitively costly linear system solves. Our algorithm exploits the thermodynamic properties of an analog system at equilibrium, and hence requires an analog thermodynamic computer. The training occurs in a hybrid digital-analog loop, where the gradient and Fisher information matrix (or any other positive semi-definite curvature matrix) are calculated at given time intervals while the analog dynamics take place. We numerically demonstrate the superiority of this approach over state-of-the-art digital first- and second-order training methods on classification tasks and language model fine-tuning tasks.

## 1 Introduction

With the rise of more sophisticated AI models, the cost of training them is exploding, as world-leading models now cost hundreds of millions of dollars to train. This issue is compounded by the ending of both Moore’s Law and Dennard’s Law for digital hardware [], which impacts both the runtime and energy efficiency of such hardware. This highlights a need and an opportunity for specialized, unconventional hardware targeted at improving the efficiency of training AI models.

Moreover, conventional digital hardware can be viewed as limiting the range of training algorithms that a user may consider. Researchers are missing an opportunity to co-design novel optimizers to exploit novel hardware developments. Instead, relatively simplistic optimizers, such as stochastic gradient descent (SGD), Adam [], and their variants [], are among the most popular methods for training deep neural networks (DNNs) and other large AI models. More sophisticated optimizers are rarely used due to the associated computational overhead on digital hardware.

A clear example of this is second-order methods, which capture curvature information of the loss landscape. These methods, while theoretically more powerful in terms of convergence properties, remain computationally expensive and harder to use, blocking their adoption. For example, natural gradient descent (NGD) [, ] involves calculating estimates of second-order quantities such as the Fisher information matrix and performing a costly linear system solve at every epoch. Some approximations to NGD, such as the Kronecker-factored approximate curvature (K-FAC) [], have shown promise, and K-FAC has shown superior performance to Adam [, ]. However, applying such methods to arbitrary neural network architectures remains difficult [].

In this article, we present thermodynamic natural gradient descent (TNGD), a new method to perform second-order optimization. This method involves a hybrid digital-analog loop, where a GPU communicates with an analog thermodynamic computer. A nice feature of this paradigm is flexibility: the user provides their model architecture and the analog computer serves only to accelerate the training process. This is in contrast to many proposals to accelerate the inference workload of AI models with analog computing, where the model is hardwired into the hardware, and users are unable to change the model architecture as they seamlessly would by using their preferred software tools [, , , ].

The analog computer in TNGD uses thermodynamic processes as a computational resource. Such thermodynamic devices have previously been proposed [, , , , ], have been theorized to exhibit runtime and energy efficiency gains [, ], and have been successfully prototyped [, ]. Our TNGD algorithm represents an instance of algorithmic co-design, where we propose a novel optimizer to take advantage of a novel hardware paradigm. TNGD exploits a physical Ornstein–Uhlenbeck process to implement the parameter update rule in NGD. It has a runtime per iteration scaling linearly in the number of parameters, and when properly parallelized it can be close to the runtime of first-order optimizers such as Adam and SGD. Hence, it is theoretically possible to achieve the computational efficiency of a first-order training method while still accounting for the curvature of the loss landscape with a second-order method. Moreover, our numerics show the competitiveness of TNGD with first-order methods for classification and extractive question-answering tasks.

## 2 Related work

There is a large body of theoretical research on natural gradient descent [, , ] arguing that NGD requires fewer iterations than SGD to converge to the same value of the loss in specific settings. While less is known about the theoretical convergence rate of Adam, there exists a large body of empirical evidence that NGD can converge in fewer iterations than Adam [, , , , , ].

However, a single iteration of NGD is generally more computationally expensive than that of SGD or Adam, which have a per-iteration cost scaling linearly in the number of parameters $N$. NGD typically has a superlinear (assuming the condition number scales as $\kappa=N^{\alpha},\alpha>0$ for NGD-CG) complexity in the number of parameters (although this may be reduced to linear scaling at the expense of higher-order scaling with batch size and output dimension, see Section 3). K-FAC [] aims to reduce this complexity and invokes a block-wise approximation of the curvature matrix, which may not always hold. While first introduced for multi-layer perceptrons, K-FAC has been applied to more complex architectures, such as recurrent neural networks [] and transformers [], where additional approximations have to be made and where the associated computational overhead can vary.

There has been significant effort and progress towards reducing the time- and space- complexity of operations used in the inference workload of AI models, e.g., a variety of “linear attention" blocks have been proposed [, , ]. However, there has been less focus on reducing the complexity of training methods. While various approaches are taken to accelerating training using novel hardware, these efforts typically aim at reducing the constant coefficients appearing in the time cost of computation. Especially relevant to our work, analog computing devices have been proposed to achieve reduced time and energy costs of training relative to available digital technology [, , , ]. These devices are generally limited to training a neural network that has a specific architecture (corresponding to the structure of the analog device). To our knowledge, there has not yet been a proposal that leverages analog hardware to reduce the complexity of training algorithms such as NGD.

Given the existing results implying that fewer iterations are needed for NGD relative to other commonly used optimizers, we focus on reducing the per-iteration computational cost of NGD using a hybrid analog-digital algorithm to perform each parameter update. Our algorithm therefore demonstrates that complexity can be improved in training (not only in inference), and moreover that the per-iteration complexity of NGD can be made similar to that of a first-order training method.

## 3 Natural gradient descent

Let us consider a supervised learning setting, where the goal is to minimize an objective function defined as:

$$ $\ell(\theta)=\frac{1}{|\mathcal{D}|}\sum_{(x,y)\in\mathcal{D}}L(y,f_{\theta}(x )),$ (1) $$

where $L(y,f_{\theta}(x))\in\mathbb{R}$ is a loss function, $f_{\theta}(x)$ is the forward function that is parametrized by $\theta\in\mathbb{R}^{N}$. These functions depend on input data and labels $(x,y)\in\mathcal{D}$, with $\mathcal{D}$ a given training dataset. Viewed through the lens of statistics, minimizing the objective function is analogous to minimizing the Kullback-Leibler (KL) divergence from the target joint distribution $q(x,y)$ to the learned distribution $p(x,y|\theta)$ [].
A straightforward way to optimize $\ell(\theta)$ is to follow the direction of steepest descent, defined by the negative gradient $-\nabla\ell$, defined as:

$$ $\displaystyle\frac{-\nabla\ell}{||\nabla\ell||}=\underset{\epsilon\rightarrow 0 }{\mathrm{lim}}\;\frac{1}{\epsilon}\,\underset{d:||d||\leq\epsilon}{\mathrm{ arg\,min}}\,\ell(\theta+d),$ (2) $$

with $||\cdot||$ the Euclidean norm. The natural gradient, on the other hand can be defined as the direction of steepest descent with respect to the KL divergence defined as:

$$ $\displaystyle\text{KL}(p(x,y|\theta+d)||p(x,y|\theta))=\iint p(x,y|\theta+d)\ \log\left(\frac{p(x,y|\theta+d)}{p(x,y|\theta)}\right)\ \mathrm{d}x\mathrm{d}y$ (3) $$

[]. One may then Taylor-expand this divergence as

$$ $\displaystyle\text{KL}(p(x,y|\theta+d)||p(x,y|\theta))=\frac{1}{2}d^{\top}Fd+O (d^{3}),$ (4) $$

where $F$ is the Fisher information matrix [] (or the Fisher), defined as:

$$ $\displaystyle F=\mathbb{E}_{p(x,y|\theta)}[\nabla\log p(x,y|\theta)\nabla\log p (x,y|\theta)^{\top}].$ (5) $$

The natural gradient is then simply defined as

$$ $\displaystyle\tilde{g}=F^{-1}\nabla\ell(\theta).$ (6) $$

For the NGD optimizer, the update rule is then given by:

$$ $\theta_{k+1}=\theta_{k}-\eta F^{-1}\nabla\ell,$ (7) $$

with $\eta$ a learning rate.
In practice, computing the Fisher information is not always feasible because one must have access to the density $p(x,y|\theta)$. A quantity that is always possible (and relatively cheap) to compute thanks to auto-differentiation is the empirical Fisher information matrix, defined as:

$$ $\displaystyle\bar{F}=JJ^{\top}=\frac{1}{b}\sum_{(x,y)\in\mathcal{S}}\nabla\log p (y|x,\theta)\nabla\log p(y|x,\theta)^{\top},$ (8) $$

where $\log p(y\mid x,\theta)=-L(y,f_{\theta}(x))$, $|\mathcal{S}|=b$ is the batch size and $\mathcal{S}\subset\mathcal{D}$. The Jacobian matrix $J$ is defined as

$$ $J~{}=\frac{1}{\sqrt{b}}[\nabla\log p(y_{1}|x_{1},\theta),\nabla\log p(y_{2}|x_ {2},\theta),\ldots,\nabla\log p(y_{b}|x_{b},\theta)].$ $$

Note that the squared gradient appearing in the second moment estimate of the Adam optimizer [] is the diagonal of the empirical Fisher matrix. Another approximation to the Fisher matrix is the generalized Gauss-Newton (GGN) matrix, defined as:

Figure: Figure 1: Overview of Thermodynamic Natural Gradient Descent (TNGD). A GPU that stores the model architecture and provides the gradient $\nabla\ell_{k}$ and Fisher matrix $F_{k}$ (through its representation given by the Jacobian $J_{f}$ and Hessian $H_{L}$ matrices given by Eq. (9)) at step $k$ is connected to a thermodynamic computer, called the stochastic processing unit (SPU). At times $t_{k}$, the estimate of the natural gradient $\tilde{g}_{k}$ is sent to the GPU, which updates the parameters of the model and calculates gradients and curvature matrices for some new data batch $(x_{k},y_{k})$. During digital auto-differentiation, the SPU undergoes dynamical evolution, either continuing to approach its steady-state or remaining in it. After some time, gradient $\nabla\ell_{k}$ and Fisher matrix $F_{k}$ are sent to the SPU through a DAC and digital controllers. This modifies the dynamics of the SPU, and after some time interval, a new natural gradient estimate $\tilde{g}_{k+1}$ is sent back to the GPU. Note that the time between two measurements $t_{k+1}-t_{k}$ need not be greater than the time between two auto-differentiation calls. The hybrid digital-thermodynamic process may be used asynchronously as shown in the diagram (where the time of measurement of $\tilde{g}$ and upload of the gradient and Fisher matrix are not the same).

$$ $G=J_{f}H_{L}J_{f}^{\top}=\frac{1}{b}\sum_{(x,y)\in\mathcal{S}}J_{f}^{(x,y)}H_{ L}^{(x,y)}J_{f}^{{(x,y)}\top},$ (9) $$

where $J_{f}^{(x,y)}$ is the Jacobian of $f_{\theta}(x)$ with respect to $\theta$ and $H_{L}^{(x,y)}$ is the Hessian of $L(y,z)$ with respect to $\theta$ evaluated at $z=f_{\theta}(x)$. $J_{f}$ is a $bd_{z}\times N$ matrix, and $H_{L}$ is a $bd_{z}\times bd_{z}$ matrix, where $d_{z}$ is the output dimension of $z=f_{\theta}(x)$ and $N$ is the number of parameters ($N$ also depends on $d_{z}$, where for deep networks it is a weak dependence).

For loss functions of the exponential family (with natural parameter $z$), the GGN matches the true Fisher matrix []. In addition, we have observed better convergence with the GGN than with the empirical Fisher (as in other works such as Refs. [, ], where better convergence than with the Hessian is also observed). Therefore, we will consider the GGN in what follows. Note that the methods we introduce in this work apply to any second-order optimization algorithm with a positive semi-definite curvature matrix (by curvature matrix, we mean any matrix capturing information about the loss landscape). In particular, it applies most efficiently to matrices constructed as outer products of rectangular matrices (such as the empirical Fisher and the GGN) as explained below.

### 3.1 Fast matrix vector products

The linear system appearing in Eq. (6) can be solved using the conjugate gradient (CG) method [], which will be referred to as NGD-CG in what follows. In fact, when $\ell$ is parametrized by a neural network, the GGN-vector product $Gv$ involved in the conjugate gradient algorithm may be evaluated in runtime $O(bN)$ thanks to fast Jacobian-vector products [] (JVPs). This approach also enables one to not explicitly construct the Fisher matrix, thus also avoiding a $O(bd_{z}N^{2})$ runtime cost in computing it and a $O(N^{2})$ memory cost in storing it.
The efficiency of this approach depends on the number of CG iterations required to obtain good performance. Importantly, convergence in $\sqrt{\kappa}$ steps, with $\kappa$ the condition number of $F$, is not required to obtain competitive performance [, ].
Crucially, due to the sequential nature of the algorithm, the CG iterations cannot be parallelized.

In practice, since reaching convergence is computationally expensive, one generally stops the CG algorithm after a set number of iterations. Because of the way the step size is adapted in CG, we have observed that the solution after $k$ steps $x_{k}$ is not necessarily closer to the true solution than the initial guess $x_{0}$, in particular for ill-conditioned problems, which can make NGD-CG difficult to use.

### 3.2 NGD with the Woodbury identity

In the machine learning setting, it is often the case that $b\ll N$ (and $d_{z}\ll N$). This means that the curvature matrix is low-rank and the linear system to solve is underdetermined. To mitigate this issue, the Fisher matrix may be dampened as $F+\lambda\mathbb{I}$. In that case, the Woodbury identity may be used to obtain the inverse Fisher vector-product $F^{-1}v$ appearing in the NGD update. We have:

$$ $\displaystyle F$ $\displaystyle=UV+\lambda\mathbb{I},\text{ with }U=J_{f},V=H_{L}J_{f}^{\top}$ (10) $\displaystyle F^{-1}$ $\displaystyle=\lambda^{-1}\mathbb{I}-\lambda^{-2}U(\mathbb{I}+\lambda^{-1}VU)^ {-1}V\qquad(\mathrm{Woodbury})$ (11) $\displaystyle F^{-1}v$ $\displaystyle=\lambda^{-1}\mathbb{I}-\lambda^{-2}U(\mathbb{I}+\lambda^{-1}VU)^ {-1}Vv$ (12) $$

This is included in Ref. [], and can be competitive with NGD-CG when the batch size $b$ and output dimension $d_{z}$ are much smaller than the number of trainable parameters $N$. Here one must construct the $V$ matrix, which has runtime $O(d_{z}^{2}b^{2}N)$, and invert $(\mathbb{I}+\lambda^{-1}VU)$ which is $O(b^{3}d_{z}^{3})$. While the batch size typically remains small, the value of $d_{z}$ can make this inversion intractable. For example, in many language-model tasks, $d_{z}\sim O(10^{4})$ is the vocabulary size.

## 4 Thermodynamic NGD

At a high level, TNGD combines the strength of GPUs (through auto-differentiation) with the strength of thermodynamic devices at solving linear systems. Regarding the latter, Ref. [] showed that a thermodynamic device, called a stochastic processing unit (SPU), can solve a linear system $Ax=b$ with reduced computational complexity relative to standard digital hardware. The solution to the linear system is found by letting the SPU evolve under an Ornstein–Uhlenbeck (OU) process given by the following stochastic differential equation (SDE):

$$ $dx=-(Ax-b)dt+\mathcal{N}\left[0,2\beta^{-1}\,dt\right],$ (13) $$

where $A$ is a positive matrix and $\beta$ is a positive scalar (which can be seen as the inverse temperature of the noise).
Operationally, one lets the SPU settle to its equilibrium state under the dynamics of Eq. (13), at which point $x$ is distributed according to the Boltzmann distribution given by:

$$ $x\sim\mathcal{N}[A^{-1}b,\beta^{-1}A^{-1}].$ (14) $$

One can see that the first moment of this distribution is the solution to the linear system $Ax=b$. Exploiting this approach, TNGD involves a subroutine that estimates the solution to the linear system in Eq. (6). For this particular linear system, the SDE in Eq. (13) becomes the following:

$$ $\displaystyle d\tilde{g}_{k,t}$ $\displaystyle=-(F_{k-1}\tilde{g}_{k,t}-\nabla\ell_{k-1})dt+\mathcal{N}\left[0, 2\kappa_{0}dt\right]$ (15) $\displaystyle=-(J_{f,k-1}^{\top}H_{L,k-1}J_{f,k-1}\tilde{g}_{k,t}-\nabla\ell_{ k-1})dt+\mathcal{N}\left[0,2\kappa_{0}dt\right]$ (16) $$

with $\tilde{g}_{k,t}$ the value of the natural gradient estimate at time $t$ and $\kappa_{0}$ the variance of the noise. Comparing Eqs. (13) and (15), we see that in the equilibrium state (i.e. for large $t$), the mean of $\tilde{g}_{k,t}$ provides an estimate of the natural gradient, in other words:

$$ $\displaystyle\tilde{g}_{k}:=\underset{t\rightarrow\infty}{\mathrm{lim}}\langle \tilde{g}_{k,t}\rangle=F_{k-1}^{-1}\nabla\ell_{k-1}.$ (17) $$

**Table 1: Runtime and memory complexity of optimizers considered in this paper. All operations are per iteration. The first line corresponds to first-order optimizers that evaluate the gradient only, and apply diagonal rescalings and $O(N)$ operations to it only. Vanilla NGD (second line) includes the explicit storage and inversion of the GGN matrix as well as its construction, dominating the runtime and memory cost. NGD-CG (third line) can be performed by running $c$ iterations, each dominated by GGN-vector products and has the same memory cost as first-order methods. NGD-Woodbury can be performed by constructing the matrix $VU$, and using the formula given by Eq. (12). This results in a runtime cost dominated by constructing $VU$ and inverting it, which also requires its storage.**
| Optimizer | Runtime | Memory | Model calls |
| --- | --- | --- | --- |
| SGD/Adam | $O(bN)$ | $O(N)$ | $1$ |
| NGD | $O(N^{3}+bd_{z}N^{2})$ | $O(N^{2})$ | $bd_{z}$ |
| NGD-CG | $O(cbN)$ | $O(N)$ | $2c$ |
| NGD-Woodbury | $O(b^{2}d_{z}^{2}N+b^{3}d_{z}^{3})$ | $O(bd_{z}N+b^{2}d_{z}^{2})$ | $bd_{z}$ |
| Thermodynamic NGD | $O(bd_{z}N+t)$ | $O(bd_{z}N+b^{2}d_{z}^{2})$ | $bd_{z}$ |

The overall TNGD algorithm is illustrated in Fig. 1. Using the current parameter estimates $\theta_{k}$, the GPU computes the matrices $J_{f}$ and $H_{L}$, and the vector $\nabla\ell$, which can be accomplished efficiently using auto-differentiation. The matrices $J_{f}$, $J_{f}^{\top}$, and $H_{L}$, as well as the vector $\nabla\ell$, are uploaded to component values (see Appendix) on the SPU, which is then allowed to equilibrate under the dynamics of Eq. (15). Next, samples are taken of $\tilde{g}_{t,k}$, and are sent from the SPU to the GPU, where samples are averaged to yield an estimate of $\tilde{g}_{k}$. Finally, the parameters are updated using the equation

$$ $\theta_{k+1}=\theta_{k}-\eta\tilde{g}_{k},$ (18) $$

and this process may be repeated until sufficient convergence is achieved (other update equations may also be employed, see Section 5).

While Eq. (17) involves a long time limit, numerical evidence (see section 5) shows that samples may be taken even before equilibrium has been reached without harming performance significantly. Thus, the analog dynamics time $t$ is an important hyperparameter of TNGD. Furthermore, another hyperparameter arises from the delay time $t_{d}$, defined as the time between a measurement of $\theta_{k}$ and the update of the gradient and GGN on the device. As discussed in Section 5, a non-zero delay time is not necessarily detrimental to performance and can in fact improve it.

In addition to the advantage in time- and energy-efficiency, TNGD has another advantage over NGD-CG in terms of stability. For some pathological linear systems, CG fails to converge and instead diverges. However, the thermodynamic algorithm is guaranteed to converge (on average) for any positive definite matrix. To see this, note that the mean of $\tilde{g}_{k,t}$ evolves according to

$$ $\langle\tilde{g}_{k,t}\rangle=\exp{(-F_{k-1}t)}(\tilde{g}_{k,0}-F_{k-1}^{-1} \nabla\ell_{k-1})+F_{k-1}^{-1}\nabla\ell_{k-1}.$ (19) $$

There is still variance associated with the estimator of $\langle\tilde{g}_{k,t}\rangle$ (the sample mean), but the sample mean converges to the solution with high probability in all cases. We also note that if we choose $\tilde{g}_{k,0}=\nabla\ell_{k-1}$, we obtain a smooth interpolation between SGD ($t=0$) and NGD ($t=\infty$).

Figure: Figure 2: Runtime per iteration of second-order optimizers considered in this paper. (a) The runtimes per iteration are compared for NGD, NGD-CG, NGD-Woodbury, and TNGD (estimated) for various $N$. Here the convolutional network we applied to MNIST is used and the dimension of the hidden layer is varied to vary $N$ for fixed $d_{z}=20$. (b) The same comparison is shown for various values of $d_{z}$. The same network is used and $d_{z}$ is varied (this also has the effect of varying the $N$). Error bars are displayed as shaded area but are smaller than the data markers.

### 4.1 Computational complexity and performance

The runtime complexity of TNGD and other second-order optimization (that do not make assumptions on the structure of $G$, hence excluding K-FAC) algorithms is reported in Table 1. As explained, Thermodynamic NGD (TNGD) has a runtime and memory cost dominated by the construction and storage (before sending them off to the analog hardware) of the Jacobian of $f_{\theta}(x)$ and the Hessian of the loss. The $t$ factor denotes the analog runtime, and may be interpreted similarly to $c$ for NGD-CG as a parameter controlling the approximation. For each optimizer the number of model calls is reported. For all optimizers except NGD-CG these calls can be easily parallelized thanks to vectorizing maps in PyTorch.

In Fig. 2 a comparison of the runtime per iteration of the four second-order optimizers considered is shown. Fig. 2(a) shows the runtime as a function of the number of parameters $N$. The scaling of NGD as $N^{3}$ can be observed, and the NGD-CG data is close to flat, meaning the model calls parallelize well for the range of parameter count considered. The linear scaling of NGD-Woodbury and TNGD is also shown, although with a different overall behaviour due to parallelization and a much shorter runtime per iteration for TNGD. This shows that for the given range of $N$ at $d_{z}=20$, we can expect a 100$\times$ speedup over second-order optimizers. Fig. 2(b) shows the dependence of runtime on the output dimension $d_{z}$ for the second-order optimizers. These results indicate that TNGD is most competitive for intermediate values of $d_{z}$. Finally we note that with better hardware, the scaling with both $N$ and $d_{z}$ would be better, as the operations to construct the Hessian and Jacobian can be more efficiently parallelized for larger values.

## 5 Experiments

### 5.1 MNIST classification

We first consider the task of MNIST classification []. For our experiments, we use a simple convolutional neural network consisting of a convolutional layer followed by two feedforward layers, and we digitally simulate the TNGD algorithm (see App. D). The goal of these experiments is twofold: (1) to compare the estimated performance per runtime of TNGD against popular first-order optimizers such as Adam, and (2) to provide some insights on other features of TNGD, such as its performance as a function of the analog runtime $t$ as well as its asynchronous execution as a function of the delay time $t_{d}$.

Figure: Figure 3: Performance comparison of Adam and TNGD (simulated) on MNIST classification. (a) Training (dashed lines) and test loss (solid lines) for Adam (darker colors) and TNGD (lighter colors) are plotted against runtime (measured for Adam, and estimated for TNGD from the timing model described in Section 4.1). Shaded areas are standard deviations over five random seeds. Note that Adam includes adaptive averaging of first and second moment estimates with $(\beta_{1},\beta_{2})=(0.9,0.999)$, while TNGD does not. (b) $1-\mathrm{Accuracy}$ for training and test sets.

In Fig. 3(a), the training and test losses as a function of runtime for both Adam (measured) and TNGD (estimated) are presented. To estimate the TNGD runtime, we took into account results for its runtime per iteration as presented in the previous section, finding an overall $2\times$ runtime per iteration with respect to Adam for this problem on an A100 GPU. One can see from the figure that even while taking into account the difference in runtime per iteration, TNGD still outperforms Adam, especially at the initial stages of the optimization. Interestingly, it also generalizes better for the considered experimental setup. In Fig.3(b), the training and test accuracies are shown. We again see TNGD largely outperforming Adam, reaching the same training accuracy orders of magnitude faster, while also displaying a better test accuracy. These results are reminiscent of prior work on NGD [], however here the batch size is smaller than in other works, indicating that even a noisy GGN matrix improves the optimization.

As mentioned previously, the continuous-time nature of TNGD allows one to interpolate smoothly between first- ($t=0$) and second- ($t=\infty$) order optimization, with a given optimizer choice (whether the optimizer update rule is that of SGD or that of Adam as described in Alg. 1). In Fig. 4(a), the training loss vs. iterations is shown for various analog dynamics times. These results clearly demonstrate the effect mentioned above, where increasing the analog runtime improves performances continuously until it approaches that of exact NGD for $t\sim 50\tau$. In Fig. 4(b), the same quantity is shown for a fixed analog dynamics time $t$, and varying delay times $t_{d}$. This leads to a quadratic approximation of the objective function that is inaccurate (since the GGN and gradients are calculated for parameters different than the value around which the objective function is approximated). However, this results in an improved performance, even for a small delay time. A likely explanation of this result is that the state of the device retains information about the curvature of the previous quadratic approximation, while being subject to the updated quadratic approximation. This effect propagates across iterations which is reminiscent of momentum.

Figure: Figure 4: Training loss vs. iterations for varying analog dynamics times. (a) The training loss is shown for NGD (dashed line) and for TNGD with various analog dynamics times $t$ (solid lines). (b) The training loss is shown for NGD (dashed line) and for TNGD with fixed analog dynamics time $t=5\tau$ and varying delay times $t_{d}$ (solid lines). The delay appears to have a momentum effect, which can even lead to TNGD outperforming exact NGD for certain analog dynamics and delay times. Shaded areas are standard deviations over five random seeds.

### 5.2 Language model fine-tuning

In this section we show how thermodynamic NGD may be applied to language modeling tasks, in more practically relevant settings than MNIST classification. We consider the DistilBert model [] which we fine-tune on the Stanford question-answering dataset (SQuaD) [], a common dataset to evaluate model comprehension of technical domains through extractive question-answering. As is commonly performed when fine-tuning, we apply a low-rank adaptation [] to the model, which reduces its trainable parameters (details about this procedure are in App. E) to a manageable amount ($75k$ here) for limited compute resources.

Figure 5(a) displays a comparison of the training loss for different optimizers. The bare TNGD (as used in the previous section) shows a worse performance than Adam in this setting. However, a hybrid approach, TNGD-Adam, where the natural gradient estimate is used in conjunction with the Adam update rule gives the best performance (this is explained in App. B). One possible explanation for this result is that there are two pre-conditionings of the gradient for TNGD-Adam: the first comes from the natural gradient, which incorporates curvature information, and the second comes from the Adam update rule, which acts as a signal-noise ratio as explained in Ref. [], which further adjusts the natural gradient values. In Fig. 5(b), we show that the same results as in the previous section apply to TNGD-Adam, where increasing the analog runtime boosts performance. Therefore, the analog runtime in TNGD may be viewed as a resource in this sense, that is computationally very cheap (as time constants can be engineered to be very small).

Figure: Figure 5: Training loss vs. iterations for QA fine-tuning. (a) Comparison of the performance per iteration of TNGD, Adam, and TNGD-Adam, where the latter uses the natural gradient estimate in conjunction with the Adam update rule with $(\beta_{1},\beta_{2})=(0,0)$. (b) Performance of the TNGD-Adam optimizer for various analog dynamics times. Similar to Fig. 4, the performance improves as $t$ grows.

## 6 Limitations

The practical impact of our work relies on the future availability of analog thermodynamic computers, such as a scaled up version of the system in Ref. []. We provide a circuit diagram of a potential thermodynamic computer in the Appendix. Such computers can employ standard electrical components and leverage CMOS-based fabrication infrastructure, and hence are likely straightforward to scale up, although that remains to be demonstrated.

Analog computers, in general, tend to face precision issues, whereby the solution accuracy is limited by the precision of the electrical components. For analog thermodynamic computers, it is possible to mitigate this issue through an averaging technique [], and the method proposed in Ref. [] can be directly applied to the TNGD algorithm to improve solution accuracy. Nevertheless, we suspect that training-based applications will have a significant tolerance to precision-based errors, although a detailed study is needed to confirm that hypothesis. We note that there is a growing body of work on very low-precision inference [] and training [] which indicates that high numerical precision is not crucial for good performance in machine learning.
We also remark that thermodynamic computers are predicted to be robust to stochastic noise sources since stochasticity is a key component of such computers [], as is shown in Fig. 7 in the Appendix.

We have numerically tested TNGD for a small subset of potential tasks such as MNIST classification and DistilBert fine-tuning on the SQuaD dataset, for a small number of epochs. Hence, seeing if the advantage we observe for TNGD also holds for other applications is an important direction.

## 7 Conclusion

This work introduced Thermodynamic Natural Gradient Descent (TNGD), a hybrid digital-analog algorithm that leverages the thermodynamic properties of an analog system to efficiently perform second-order optimization. TNGD greatly reduces the computational overhead typically associated with second-order methods for arbitrary model architectures. Our numerical results on MNIST classification and language model fine-tuning tasks demonstrate that TNGD outperforms state-of-the-art first-order methods, such as Adam, and provide large speedups over other second-order optimizers. This suggests a promising future for second-order methods when integrated with specialized hardware.

Looking forward, our research stimulates further investigation into TNGD, particularly with enhancements such as averaging techniques and moving averages. Extensions to approximate second-order methods such as K-FAC may also be possible. Moreover, the principles of thermodynamic computing could inspire new algorithms for Bayesian filtering. While the current impact of our work relies on the development and availability of large-scale analog thermodynamic computers, the theoretical and empirical advantages presented here underscore the potential of co-designing algorithms and hardware to overcome the limitations of conventional digital approaches.

## Appendix A Levenberg-Marquardt regularization schedule

Poor-conditioning and singularity of the curvature matrix can greatly decrease the performance of NGD, which is dealt with by adding a term $\lambda\mathbb{I}$ to the curvature matrix. Following  [], it is possible to use a simple method to adapt the value of $\lambda$ at each time step, known as a Levenberg-Marquardt schedule. This involves computing the reduction ratio $\rho$, defined as:

$$ $\displaystyle\rho=\frac{\ell(\theta_{k+1})-\ell(\theta_{k})}{q_{\theta_{k}}( \theta_{k+1}-\theta_{k})-q_{\theta_{k}}(0)}$ (20) $$

with $q_{\theta_{k}}(p)$ the quadratic approximation to $\ell$ around $\theta_{k}$ defined as:

$$ $\displaystyle q_{\theta_{k}}(p)=\ell(\theta_{k})+\nabla\ell(\theta_{k})^{\top} p+\frac{1}{2}p^{\top}G_{k}p.$ (21) $$

If $\rho>a$, $\lambda\leftarrow\alpha\lambda$, and if $\rho<1-a,\lambda\leftarrow\lambda/\alpha$. This can be interpreted as distrusting the quadratic model when $\rho$ is small, hence increasing $\lambda$ for the next iteration. This procedure may be used for TNGD, however this adds a supplementary digital cost of a GGN-vector product $G_{k}p$ (which has a similar cost to two JVPs). For our experiments we did not find it to significantly boost performance although it may be considered for future work.

## Appendix B TNGD algorithm

In Alg. 1 we provide the steps for the TNGD algorithm. This algorithm may be used in conjunction with various digital optimizers (such as SGD or Adam). The thermodynamic linear solver (TLS) is performed by an analog thermodynamic computer whose physical implementation is described in appendix C. The TLS takes as inputs the Jacobian $J_{f,k}$, the Hessian $H_{L}$, the gradient $g_{k}$ and an initial point $x_{0}$ (that can be reset at each iteration, or not, in which case $t_{d}>0$).

Figure: Algorithm 1 Thermodynamic Natural Gradient Descent

## Appendix C Hardware implementation

The thermodynamic NGD algorithm can be implemented in similar hardware to what is presented in Ref. [, ]. However, this requires one to construct the full curvature matrix, which is quadratic in the number of parameters, and then send it to the analog hardware. Therefore, an alternative hardware implementation that is described by the same electronic circuit equations is preferred. This alternative implementation is comprised of three arrays of resistors of size $(bd_{z},N),(bd_{z},bd_{z})$ and $(N,bd_{z})$ for storing $J_{f},H_{L}$ and $J_{f}^{\top}$, respectively (hence two of these are rectangular resistor arrays). These three arrays of resistors enable one to implement the following differential equation in hardware:

$$ $dV=-(J_{f}H_{L}J_{f}^{\top}+\lambda\mathbb{I})Vdt-bdt+\mathcal{N}(0,2\kappa_{0 }\sqrt{dt})$ (22) $$

where $\kappa_{0}$ is the noise variance and $V=(V_{1},V_{2},\ldots,V_{N})$ is a vector of voltages.

To understand this let us consider a single resistor resistor array shown in Fig. 6. By Kirchhoff’s current law, we obtain the equation of motion for the vector of voltages $V=(V_{1},V_{2},V_{3})$ as:

$$ $C\dot{V}=-\mathcal{G}V+R^{-1}V_{\mathrm{in}}+I_{\mathrm{n}},$ (23) $$

with $V_{\mathrm{in}}=(V_{\mathrm{in}1},V_{\mathrm{in}2},V_{\mathrm{in}3})$, $R=\mathrm{diag}(R_{1},R_{2},R_{3})$, $C=\mathrm{diag}(C_{1},C_{2},C_{3})$, and $I_{\mathrm{n}}=(I_{\mathrm{n}_{1}},I_{\mathrm{n}_{2}},I_{\mathrm{n}_{3}})$, which is the current noise vector and is assumed to be Gaussian with zero mean and variance $2\kappa_{0}$. In this case we have

$$ $\mathcal{G}=\begin{pmatrix}\frac{1}{R_{11}}&\frac{1}{R_{21}}&\frac{1}{R_{31}} \\ \frac{1}{R_{12}}&\frac{1}{R_{22}}&\frac{1}{R_{32}}\\ \frac{1}{R_{13}}&\frac{1}{R_{23}}&\frac{1}{R_{33}}\end{pmatrix}.$ (24) $$

These resistor values need to be tunable such that different Jacobians and Hessians may be given as inputs throughout the training process (and for the hardware to be used for different problems).

At steady state ($\dot{V}=0$), the average voltage vector is $\langle V\rangle=\mathcal{G}^{-1}R^{-1}V_{\mathrm{in}}$, which corresponds to the solution of the linear system $Ax=b$ with $A=\mathcal{G}$, $x=V$, $b=R^{-1}V_{\mathrm{in}}$.

One may compose three arrays of resistors to obtain Eq. (22), giving a total resistor count of $bd_{z}(bd_{z}+2N)$ (with two of them having no capacitors, which enablies one to obtain a first-order SDE). The damping term proportional $\lambda$ may be obtained by adding resistors, which has the physical effect of stabilizing the electrical system (as it does numerically).

Figure: Figure 6: Circuit diagram for the thermodynamic device in the case of a single resistor array implementation for a 3-dimensional problem. The device is comprised of three voltage sources, each of which is connected to three resistors $\{R_{i}\}$ . Each of these resistors is connected to a line that goes into the negative pin of a different operational amplifier. A capacitor connects the negative pin of the operational amplifier to the operational amplifier’s output port, where the voltage is denoted by $\{V_{i}\}$. The output ports of the operational amplifiers are connected to an array of $N\times N$ resistors $\{R_{ij}\}$ (nine here), each of which connects to the line going from the resistors $\{R_{i}\}$ to the negative pins of the operational amplifiers. This feedback loop enables the circuit to run a differential equation whose steady-state corresponds to the solution of a linear system of equations.

One may run the thermodynamic linear solver by setting the voltage values $V_{\mathrm{in}}$ to the the gradient $\nabla\ell$ with a digital-to-analog converter, and set the values of the programmable resistors thanks to a digital controller.

To obtain the comparisons to other digital methods, we considered the following procedure to run the TLS on electrical hardware. In such a device the $\tau=RC$ time constant sets the characteristic timescale of the thermodynamic device.

- 1.
Digital-to-analog (DAC) conversion of the the gradient vector with a given bit-precision.
- 2.
Set the configuration of the programmable resistors ($bd_{z}(bd_{z}+2N)$) values with a given bit precision to set).
- 3.
Let the dynamics run for $t$ (the analog dynamic time). Note that for simulations this time was chosen heuristically by exploring convergence in the solutions of the problem of interest.
- 4.
Analog-to-digital (ADC) conversion of the solution measured at nodes $V_{i}$ to the digital device.

The runtime estimated are based on the following assumptions:

- •
16 bits of precision.
- •
A digital transfer speed of $50Gb/s$.
- •
$R=10^{3}\,\Omega$, $C=1\,\text{nF}$, which means $RC=1\mu\text{s}$ is the characteristic timescale of the system.

Finally, note that in all cases that were investigated, the dominant contribution to the total runtime of TNGD was the digital steps to compute the gradients, Jacobian and Hessian matrices. Hence some assumptions about the DAC/ADC may be relaxed and the total TNGD runtime would be similar. The $RC$ time constant may also be reduced to make the algorithm faster, although this is found to be easily sub-dominant with respect to input operations (setting the configuration of the device).

## Appendix D Simulating TNGD

The results reported in this paper require simulating the thermodynamic device. To do so, we employ a Euler-Maruyama discretization of Eq. 15, where the update equation is:

$$ $\tilde{g}^{(k+1)}=\tilde{g}^{(k)}+\delta t(G\tilde{g}^{(k)}-\nabla\ell)+z\sqrt {2\kappa_{0}\delta t}$ (25) $$

where $\delta t$ is a step size, $z\sim\mathcal{N}(0,1)$ and the GGN-vector product $G\tilde{g}^{(k)}$ is evaluated in linear time, with no need to construct $G$ as explained in Section 3. One may consider higher-order schemes, which in general will cost $d$ GGN-vector products (hence $2d+1$ model calls, accounting for the gradient) for each step of an order $d$ solver.

With an Euler-Maruyama scheme, one therefore requires 3 model calls per time step, which results in long simulation times for the larger $t$ values we report.

## Appendix E Experimental details

All experiments except the one reported in Fig. 2 were carried out on a Nvidia A100 GPU with 80 Gb of RAM. The experiment corresponding to Fig. 2 was carried out on a AMD EPYC 7763 64-Core CPU with 32 GB of RAM (the results on the GPU had too much variance even for a large number of repetitions). For Fig. 2, $b=32$, $c=200$, and the results were obtained by repeating over 5 manual random seeds, with the standard deviation over runs being shown as shaded areas. Modifying $c$ has the simple effect of shifting the curve on the scale.

All experiments are written in PyTorch [], and we have used the posteriors library [] which supports GGN-vector products, constructing GGN matrices (for exact NGD and NGD-Woodbury) and the conjugate gradient solver in PyTorch.

### E.1 MNIST

For the MNIST experiments, we train on 10,000 images and test on 10,000 other images, with $b=64$ for 10 epochs. Below is a table with hyperparameters for each figure in the main text:

| Figure – Optimizer | Optimizer parameters |
| --- | --- |
| Fig. 3 – Adam | $\eta=0.001,\beta_{1}=0.9,\beta=0.999,\epsilon=1e-8$ |
| Fig. 3 – TNGD | $\eta=0.01,\beta=0,t=50\tau,t_{d}=0,\lambda=0.01,\delta t=0.1\tau$ |
| Fig. 2(a) – TNGD | $\eta=0.01,\beta=0,\lambda=0.01,\delta t=0.1\tau$ |

For these experiments, the plotted data is the mean (and standard deviation) of the moving average over $200$ points for the five same manual random seeds. The Adam experiments took $\sim 5$ minutes to run, while the longest TNGD experiments took $\sim 14$ hours (due to many time steps being required, see Section D. We performed sweeps over the damping and learning rate value of TNGD which we do not report in the paper that took $\sim 10$ days of accumulated total runtime.

#### E.1.1 Noisy simulation

One key feature of TNGD is that it is noise-resilient. Indeed, because the solution of the linear system of Eq. (6) is encoded in the first moment of the equilibrium distribution, any noise that is approximately Gaussian will not affect much the quality of the results for reasonable noise levels. In Fig. 7, the loss vs. iterations are shown for varying noise levels, which are defined by the value of the noise variance $\kappa_{0}$. For $\kappa_{0}<0.01$, the noise essentially does not affect the performance of TNGD (as the influence of noise of performance starts to saturate at this value), even for a very small analog dynamics time (here, $t=\tau$). For a realistic electrical device where $\theta_{t}$ are voltages, the contribution of thermal noise to the noise level would be $\kappa_{0}\sim 10^{-6}V$. Other noise sources may contribute to the noise level, but because of the nature of the TNGD algorithm, it exhibits a high noise-resilience. Note that it is also possible to collect more samples from the device to reduce influence of the noise if the noise level is large.

Figure: Figure 7: Training loss vs. iterations for varying noise levels. The noise level is defined by the noise variance $\kappa_{0}$ entering Eq. (15). Here $t=\tau$.

### E.2 Extractive question-answering

For the QA experiments, we train on 800 articles and test on 200 other articles of the SQuaD dataset, with $b=32$ for 5 epochs. Below is a table with hyperparameters for Fig. 5:

| Figure – Optimizer | Optimizer parameters |
| --- | --- |
| Fig. 5(a) – TNGD | $\eta=0.01,\beta=0,t=0.4\tau,t_{d}=0,\lambda=1$ |
| Fig. 5(a) – Adam | $\eta=0.001,\beta_{1}=0.9,\beta_{2}=0.999,\epsilon=1e-8$ |
| Fig. 5(b) – TNGD-Adam | $\eta=0.001,\beta_{1}=0,\beta_{2}=0,\epsilon=1e-8,t_{d}=0,\lambda=1,\delta t=0.<br>02\tau$ |

We apply low-rank adaptation (LoRA) to the $Q,K,V$ modules and output projection matrices of the attention layers with parameters $r=2,\alpha=32$ and a dropout of 0.1. LoRA consists in replacing the pre-trained weight matrices of the targeted layers $W_{0}$ by:

$$ $\tilde{W}=W_{0}+AB,$ (26) $$

where $A$ and $B$ are two rectangular matrices with their smaller dimension being $\alpha$ (hence $AB$ is low-rank). We used the peft package [], which interfaces smoothly with PyTorch and posteriors.

For these experiments we only report a single fixed random seed due to long simulation times. The Adam experiments took $\sim 20$ minutes, while the longest TNGD experiments took $\sim 2$ days (due to many time steps being required, see Section D. We performed sweeps over the damping and learning rate value of TNGD and Adam which we do not report in the paper that took $\sim 10$ days of accumulated total runtime.

## Peer Reviews

confidence: 3
contribution: 1
initial_rating: 3
presentation: 2
questions: 1. Natural gradient descent can be linked to mirror descent (see e.g. https://franknielsen.github.io/blog/NaturalGradientConnections/NaturalGradientConnections.pdf). They’re not strictly identical, but mirror descent is a first order method with the same time complexity as gradient descent. If the goal is to improve performance by using better conditioned gradients, wouldn’t mirror descent be a (computationally) better target algorithm than NGD?
2. Eq. 12: the first $\mathbb{I}$ should be $v$.
soundness: 2
strengths: 1. The presented approach seems to be compatible with alternative (to GPUs) hardware, although I’m not familiar with thermodynamic computing to judge it properly.
2. The proposed natural gradient approximation is theoretically justified.
summary: The paper presents thermodynamics natural gradient descent, an approximation to natural gradient descent that, instead of inverting the matrix needed for NG updates, approximates the inverse via a random walk. This is claimed to be implementable in hardware, thus offloading the matrix inverse from GPUs.
weaknesses: ## Evaluation issues
While the paper’s approach is interesting, the evaluations could be significantly improved. 

First, MNIST performance. Fig.3b shows that 
1. Adam and TNGD achieve the same test error; (Line 367 claims “TNGD outperforms Adam”, and then line 371 claims TNGD achieves better test accuracy, while it is clearly not true in Fig3b.)
2. TNGD overfits significantly more than Adamw (0 train error vs. somewhat close to test error for Adam); (Line 368 claims TNGD “generalizes better”.)
3. Most importantly, both methods achieve about 94% test accuracy on MNIST. MNIST is an extremely easy dataset – pretty much any neural network should be able to get 97-99% test accuracy (https://paperswithcode.com/sota/image-classification-on-mnist?metric=Accuracy). As Sec. 5.1 uses a conv layer with two fc layers, it should be enough for good performance as well; this suggests the evaluation was not done correctly. 

Second, NLP experiments in Sec. 5.2 only report the training loss (also, the TNGD-Adam combination presented there was not tested for MNIST).

Finally, TNGD is an approximation NGD, but no NGD baselines are shown.

With only two datasets and not convincing performance, it is hard to judge if the proposed approach (or using NGD at all) is worth the computational overhead.


## Justification for using NGD

I think the paper does not successfully justify using NGD for training neural networks. Its performance benefits are unclear from the presented results (although probably explored in other papers), but the computational overheads are very significant: 
- Tab. 1 shows that TNGD is much more expensive that SGD;
- the suggested (future) approach would involve using dedicated hardware.

---

confidence: 3
contribution: 2
initial_rating: 3
presentation: 2
questions: 1.	It seems unnecessary to take the detour by introducing the statistics point of view and Fisher Information and then the GGN, as GGN is a relatively common approach and can be derived from the loss function without necessarily introducing the KL divergence. The rest of the paper also does not ever use the Fisher Information matrix again and only uses the GGN. I suggest that the authors introduces GGN right after the loss function and cite relevant references relating the GGN to the FI matrix.
2.	This is a minor point. The ‘GGN vector product Gv ‘ has not been previously introduced before line 191. I suppose it refers to product of GGN with an arbitrary vector v? Please state explicitly.
3.	What do you mean by “convergence in \sqrt{k} steps … is not required …”, do you mean that the algorithm does not necessarily converge in \sqrt{k} steps but achieve good performance despite not converging? This sentence is confusing to me. 
4.	The authors switch between using G and F, to my understanding, the authors stick to the GGN approximation of the fisher information matrix, so I suggest that the authors stick to one notation. 
5.	I am not familiar with analog computing. From my understanding it seems that for solving the linear system, both the conjugate gradient method and the authors’ thermodynamic natural gradient descent method can be understood as minimizing the same quadratic objective, only CG also takes orthogonal gradient steps at each iteration while the thermodynamic NGD is basically gradient descent plus thermal noise. Naively I would expect CG to converge in less steps than NGD, while the authors seem to suggest otherwise. I suppose the longer convergence time of NGD is manifested in this extra factor “t”? The authors then claim that t does not need to be very long for the performance to be good, however, this seems an empirical observation, it would be nice if the authors could provide some bounds on t to show that thermodynamic NGD is indeed superior.
6.	In Fig.3, test loss almost always seems to be smaller than training loss except maybe at the end, is this because of some regularization method or do you have any explanations for this?
soundness: 3
strengths: This paper proposes a new algorithm that combines analog and digital computation to reduce the per-iteration cost of NGD, and performed thorough comparison of the scaling of the runtime between their method and various existing methods. The motivation and the method are clearly conveyed. The authors also performed several numerical experiments comparing the existing methods and TNGD.
summary: This paper proposes a method of reducing the per-iteration computational cost of NGD (a second order optimization method that has been shown to converge in less iterations than GD), using a hybrid analog-digital algorithm. The algorithm has a runtime that scales linearly with the number of parameters and can be made close to the runtime of first-order optimizers.
weaknesses: The paper could be written more clearly and concisely. I find the introduction of certain aspects too detailed and not necessarily helpful for understanding the authors’ contribution (such as the Fisher information etc.) and certain aspects too unclear for people not coming from an optimization background (such as the introduction of fast matrix vector product, the convergence speed and performance is only vaguely discussed). Also, this paper uses many different notations, and the introduction of these notations are often hidden in the text, making it very hard to read. I suggest that the author clearly and explicitly write out definitions and their claims. 
While the paper proposes a new algorithm, it seems to be a direct combination of existing works on natural gradient descent and using an SPU to solve linear systems, although because I am not familiar with analog computing, I could be wrong about my judgement on the novelty and contribution of this work. 
The paper would also benefit from more numerical comparisons, both on more datasets and also tuning different hyperparameters (such as the different hyperparameters in adam) to demonstrate the robustness of their findings.

---

confidence: 3
contribution: 4
initial_rating: 8
presentation: 3
questions: - General terminology question: In the original Amari (1998) paper (page 4), the term 'natural gradient' refers to the expression $G^{-1} \nabla \mathcal{L}(w)$, where $G$ is an arbitrary symmetric positive definite matrix. In your paper (L127), you use 'natural gradient' exclusively for the case where $G$ is the Fisher information matrix. Which interpretation is correct?

- L077: Condition number of what? Additionally, NGD-CG is not defined until later in the paper, so avoid using this acronym here.
- L159: "(By curvature matrix, we mean any matrix capturing information about the loss landscape)." Could you clarify? Information about which aspect of the loss landscape?
- L196: I looked at the cited references for the claim about $\kappa$, but found no mention of the condition number of $F$. Also, since $F$ is not fixed, what do you mean by the condition number of F? An upper bound on the condition number across all possible $F$?
- The authors may be interested in [recent work](https://arxiv.org/abs/2409.16422), suggesting that any effective learning rule can be formulated as natural gradient descent. This might help provide additional motivation for efficient natural gradient computation?
soundness: 4
strengths: I think this paper is very timely, and tackles an important topic. Using hardware (in this case, fundamental physics) to effectively compute will be essential to deep learning going forward. The paper is for the most part nicely written, and straightforward to follow. The experiments are convincing.
summary: This paper introduces a hybrid digital-analog technique for computing natural gradients, leveraging the analog properties of a thermodynamic, stochastic system to quickly invert the Fisher matrix. This inverted matrix can then be used alongside the gradient of the loss function to descend a loss function more efficiently than by using the gradient alone.
weaknesses: There are some terminological concerns/questions (below), which would improve the paper if addressed.