Variational Characterizations of Local Entropy and Heat Regularization in Deep Learning

The aim of this paper is to provide new theoretical and computational understanding on two loss regularizations employed in deep learning, known as local entropy and heat regularization. For both regularized losses, we introduce variational characterizations that naturally suggest a two-step scheme for their optimization, based on the iterative shift of a probability density and the calculation of a best Gaussian approximation in Kullback–Leibler divergence. Disregarding approximation error in these two steps, the variational characterizations allow us to show a simple monotonicity result for training error along optimization iterates. The two-step optimization schemes for local entropy and heat regularized loss differ only over which argument of the Kullback–Leibler divergence is used to find the best Gaussian approximation. Local entropy corresponds to minimizing over the second argument, and the solution is given by moment matching. This allows replacing traditional backpropagation calculation of gradients by sampling algorithms, opening an avenue for gradient-free, parallelizable training of neural networks. However, our presentation also acknowledges the potential increase in computational cost of naive optimization of regularized costs, thus giving a less optimistic view than existing works of the gains facilitated by loss regularization.


Introduction
The development and assessment of optimization methods for the training of deep neural networks has brought forward novel questions that call for new theoretical insights and computational techniques [3].The performance of a network is determined by its ability to generalize, and choosing the network parameters by finding the global minimizer of the loss may be not only unfeasible, but also undesirable.In fact, training to a prescribed accuracy with competing optimization schemes may lead, consistenly, to different generalization error [11].A possible explanation is that parameters in flat local minima of the loss give better generalization [10], [11], [5], [4] and that certain schemes favor convergence to wide valleys of the loss function.These observations have led to the design of algorithms that employ gradient descent on a regularized loss, actively seeking minima located in wide valleys of the original loss [4].While it has been demonstrated that the flatness of minima cannot fully explain generalization in deep learning [6], [15], there are various heuristic [2], theoretical [5], and empirical [4] arguments that support regularizing the loss.In this paper we aim to provide new understanding on two such regularizations, referred to as local entropy and heat regularization.
Our first contribution is to introduce variational characterizations for both regularized loss functions.These characterizations, drawn from the literature on large deviations [7], naturally suggest a two-step scheme for their optimization, based on the iterative shift of a probability density and the calculation of a best Gaussian approximation in Kullback-Leibler divergence.The schemes for both regularized losses differ only over the argument of the (asymmetric) Kullback-Leibler divergence that they minimize.Local entropy minimizes over the second argument, and the solution is given by moment matching; heat regularization minimizes over the first argument, and its solution is defined implicitly.
The second contribution of this paper is to investigate some theoretical and computational implications of the variational characterizations.On the theoretical side, we prove that if the best Kullback-Leibler approximations could be computed exactly, then the regularized losses are monotonically decreasing along the sequence of optimization iterates.This monotonic behavior suggests that the two-step iterative optimization schemes have the potential of being stable provided that the Kullback-Leibler minimizers can be computed accurately.On the computational side, we show that the two-step iterative optimization of local entropy agrees with gradient descent on the regularized loss provided that the learning rate matches the regularization parameter.Thus, the two-step iterative optimization of local entropy computes gradients implicitly in terms of expected values; this observation opens an avenue for gradient-free, paralelizable training of neural networks based on sampling.In contrast, the scheme for heat regularization finds the best Kullback-Leibler Gaussian approximation over the first argument, and its computation via stochastic optimization [17], [16] involves evaluation of gradients of the original loss.
Finally, our third contribution is to perform a numerical case-study to assess the performance of various implementations of the two-step iterative optimization of local entropy and heat regularized functionals.These implementations differ in how the minimization of Kullback-Leibler is computed and the argument that is minimized.Our experiments suggest, on the one hand, that the computational overload of the regularized methods far exceeds the cost of performing stochastic gradient descent on the original loss.On the other hand, they also suggest that for moderate-size architectures -where the best Kullback-Leibler Gaussian approximations can be computed effectively-the generalization error with regularized losses is more stable than for stochastic gradient descent over the original loss.For this reason, we investigate using stochastic gradient descent on the original loss for the first parameter updates, and then switching to optimize over a regularized loss.We also investigate numerically the choice and scoping of the regularization parameter.Our understanding upon conducting thorough numerical experiments is that, while sampling-based optimization of local entropy has the potential of being practical if parallelization is exploited and back-propagation gradient calculations are expensive, existing implementations of regularized methods in standard architectures are more expensive than stochastic gradient descent and do not clearly outperform it.
Several research directions stem from this work.A broad one is to explore the use of local entropy and heat regularizations in complex optimization problems outside of deep learning, e.g. in the computation of maximum a posteriori estimates in high dimensional Bayesian inverse problems.A more concrete direction is to generalize the Gaussian approximations within our two-step iterative schemes and allow to update both the mean and covariance of the Gaussian measures.
The rest of the paper is organized as follows.Section 2 provides background on optimization problems arising in deep learning, and reviews various analytical and statistical interpretations of local entropy and heat regularized losses.In Section 3 we introduce the variational characterization of local entropy, and derive from it a two-step iterative optimization scheme.Section 4 contains analogous developments for heat regularization.Our presentation in Section 4 is parallel to that in Section 3, as we aim to showcase the unity that comes from the variational characterizations of both loss functions.Section 5 reviews various algorithms for Kullback-Leibler minimization, and we conclude in Section 6 with a numerical case study.

Background
Neural networks are revolutionizing numerous fields including image and speech recognition, language processing, and robotics [13], [9].Broadly, neural networks are parametric families of functions used to assign outputs to inputs.The parameters x ∈ R d of a network are chosen by solving a non-convex optimization problem of the form where each f i is a loss associated with a training example.Most popular training methods employ backpropagation (i.e.automatic differentiation) to perform some variant of gradient descent over the loss f .In practice, gradients are approximated using a random subsample of the training data known as minibatch.Importantly, accurate solution of the optimization problem (2.1) is not the end-goal of neural networks; their performance is rather determined by their generalization or testing error, that is, by their ability to accurately assign outputs to unseen examples.
A substantial body of literature [4], [15], [3] has demonstrated that optimization procedures with similar training error may consistently lead to different testing error.For instance, large mini-batch sizes have been shown to result in poor generalization [11].Several explanations have been set forth, including overfitting, attraction to saddle points and explorative properties [11].A commonly accepted theory is that flat local minima of the loss f leads to better generalization than sharp minima [10], [4], [11], [5].As noted in [6] and [15] this explanation is not fully convincing, as due to the high number of symmetries in deep networks one can typically find many parameters that have different flatness but define the same network.Further, reparameterization may alter the flatness of minima.While a complete understanding is missing, the observations above have prompted the development of new algorithms that actively seek minima in wide valleys of the loss f.In this paper we provide new insights on potential advantages of two such approaches, based on local-entropy and heat regularization.

Background on Local-Entropy Regularizatoin
We will first study optimization of networks performed on a regularization of the loss f known as local entropy, given by where here and throughout ϕ x,τ denotes the Gaussian density in R d with mean x and variance τ I.For given τ, F τ (x) averages values of f focusing on a neighborhood of size τ.Thus, for F τ (x) to be small it is required that f is small throughout a τ -neighborhood of x.Note that F τ is equivalent to f as τ → 0, and becomes constant as τ → ∞. Figure 2.1 shows that local entropy flattens sharp isolated minima, and deepens wider minima.
A natural statistical interpretation of minimizing the loss f is in terms of maximum likelihood estimation.Given training data D one may define the likelihood function We remark that the right-hand side of equation (2.4) is the convolution of the likelihood ρ f with a Gaussian, and so we have (2.5) Thus, local entropy F τ can be interpreted as a regularization of the likelihood ρ f .

Background on Heat Regularization
We will also consider smoothing of the loss f through the heat regularization, defined by Note that F H τ regularizes the loss f directly, rather than the likelihood ρ f : Local entropy and heat regularization are, clearly, rather different.Figure 2.2 shows that while heat regularization smooths the energy landscape, the relative macroscopic depth of local minima is marginally modified.Our paper highlights, however, the common underlying structure of the resulting optimization problems.Further analytical insights on both regularizations in terms of partial differential equations and optimal control can be found in [5].

Notation
For any x ∈ R d and τ > 0 we define the probability density where Z x,τ is a normalization constant.These densities will play an important role throughout.
We denote the Kullback-Leibler divergence between densities p and q in R d by Kullback-Leibler is a divergence in that D KL (p q) ≥ 0, with equality iff p = q.However, the Kullback-Leibler is not a distance as in particular it is not symmetric; this fact will be relevant in the rest of this paper.

Local Entropy: Variational Characterization and Optimization
In this section we introduce a variational characterization of local entropy.We will employ this characterization to derive a monotonic algorithm for its minimization.The following result is well known in large deviation theory [7].We present its proof for completeness.Theorem 3.1.The local entropy admits the following variational characterization: Moreover, the density q x,τ defined in equation (2.6) achieves the minimum in (3.1).
Proof.For any density q, Hence, showing that q x,τ achieves the minimum.To conclude note that F τ (x) = −log(Z x,τ ), and so taking minimum over q on both sides of equation (3.2) and rearranging gives equation (3.1).

Two-step Iterative Optimization
From the variational characterization (3.1) it follows that Thus, a natural iterative approach to finding the minimizer of F τ is to alternate between i) minimization of the term in curly brackets over densities q; and ii) finding the associated minimizer over x.For the former we can employ the explicit formula given by equation (2.6), while for the latter we note that the integral term does not depend on the variable x, and that the minimizer of the map is unique, and given by the expected value of q x k ,τ .The statistical interpretation of these two steps is perhaps most natural through the variational formulation of the Bayesian update [8]: the first step finds a posterior distribution associated with likelihood ρ f ∝ exp(−f ) and prior ϕ x,τ ; the second computes the posterior expectation, which is used to define the prior mean in the next iteration.It is worth noting the parallel between this two-step optimization procedure and the empirical Bayes interpretation of local entropy mentioned in Section 2.
In short, the expression (3.3) suggests the following simple scheme for minimizing local-entropy:
2. Define x k+1 as the minimizer, E X∼qx k ,τ (X), of the map In practice, the expectation in the second step needs to be approximated.We will explore the potential use of gradient-free sampling schemes in Subsection 5.2 and in our numerical experiments.
A seemingly unrelated approach to minimizing the local entropy F τ is to employ gradient descent and set where η is a learning rate.We now show that the iterates {x k } K k=0 given by Algorithm 1 agree with those given by gradient descent with learning rate η = τ.
By direct computation Therefore, establishing that Algorithm 1 performs gradient descent with learning rate τ .This choice of learning rate leads to monotonic decrease of local entropy, as we show in the next subsection.Remark 3.1.In this paper we restrict our attention to the update scheme (3.4) with η = τ .For this choice of learning rate we can deduce theoretical monotonicity according to Theorem 3.2 below, but it may be computationally advantageous to use η = τ as explored in [4].

Majorization-Minorization and Monotonicity
We now show that Algorithm 1 is a majorization-minimization algorithm.Let where q x,τ is as in (2.6).It follows that A(x,x) = F τ (x) for all x ∈ R d and that A(x, x) ≥ F τ (x) for arbitrary x, x; in other words, A is a majorizer for F τ .In addition, it is easy to check that the updates coincide with the updates in Algorithm 1.As a consequence we have the following theorem.Theorem 3.2.(Monotonicity and stationarity of Algorithm 1) The sequence {x k } K k=0 generated by Algorithm 1 satisfies Moreover, equality holds only when x k is a critical point of F τ .
Proof.The monotonicity follows immediately from the fact that our algorithm can be interpreted as a majorization-minimization scheme.For the stationarity note that equation (3.5) shows that x k = x k+1 if and only if ∇F τ (x k ) = 0.

Heat Regularization: Variational Characterization and Optimization
In this section we consider direct regularization of the loss function f as opposed to regularization of the density function ρ f .The following result is analogous to Theorem 3.1.Its proof is similar and hence omitted.Theorem 4.1.The heat regularization F H τ admits the following variational characterization: Moreover, the density q x,τ defined in equation (2.6) achieves the minimum in (4.1).

Two-step Iterative Optimization
From equation (4.1) it follows that In complete analogy with Section 3, equation (4.2) suggests the following optimization scheme to minimize F H τ .
2. Define x k+1 by minimizing the map The key difference with Algorithm 1 is that the arguments of the Kullback-Leibler divergence are reversed.While x → D KL (q x k ,τ ϕ x,τ ) has a unique minimizer given by E X∼qx k ,τ (X), minimizers of x → D KL (ϕ x,τ q x k ,τ ) need not be unique.Moreover, the latter minimization is implicitly defined via an expectation and its computation via a Robbins-Monro [17] approach requires repeated evaluation of the gradient of f .We will outline the practical implementation of this minimization in Section 5.2.

Majorization-Minorization and Monotonicity
As in subsection 3.2 it is easy to see that is a majorizer for F H τ .This can be used to show the following theorem, whose proof is identical to that of Theorem 3.2 and therefore omitted.

Gaussian Kullback-Leibler Minimization
In Sections 3 and 4 we considered the local entropy F τ and heat regularized loss F H τ and introduced two-step iterative optimization schemes for both loss functions.We summarize these schemes here for comparison purposes: Optimization of F τ Let x 0 ∈ R d and for k = 0,...,K − 1 do: 1. Define q x k ,τ as in equation (2.6).
2. Let x k+1 be the minimizer of Optimization of F H τ Let x 0 ∈ R d and for k = 0,...,K − 1 do: 1. Define q x k ,τ as in equation (2.6).
2. Let x k+1 be a minimizer of Both schemes involve finding, at each iteration, the mean vector that gives the best approximation, in Kullback-Leibler, to a probability density.For local entropy the minimization is with respect to the second argument of the Kullback-Leibler divergence, while for heat regularization the minimization is with respect to the first argument.It is useful to compare, in intuitive terms, the two different minimization problems, both leading to a "best Gaussian".In what follows we drop the subscripts and use the following nomenclature: Note that in order to minimize D KL (ϕ q) we need log ϕ q to be small over the support of ϕ, which can happen when ϕ q or ϕ q.This illustrates the fact that minimizing D KL (ϕ q) may miss out components of q.For example, in Figure 5.1 left panel q is a bi-modal like distribution but minimizing D KL (ϕ||q) over Gaussians ϕ can only give a single mode approximation which is achieved by matching one of the modes (minimizers are not guaranteed to be unique); we may think of this as "mode-seeking".In contrast, when minimizing D KL (q ϕ) over Gaussians ϕ we want log q ϕ to be small where ϕ appears as the denominator.This implies that wherever q has some mass we must let ϕ also have some mass there in order to keep q ϕ as close as possible to one.Therefore the minimization is carried out by allocating the mass of ϕ in a way such that on average the discrepancy between ϕ and q is minimized, as shown in Figure 5.1 right panel; hence the label "mean-seeking." In the following two sections we show that, in addition to giving rather different solutions, the argument of the Kullback-Leibler divergence that is minimized has computational consequences.
5.1.Minimization of x → D KL (q x k ,τ ϕ x,τ ) The solution to this minimization problem is unique and given by E X∼qx k ,τ (X).For notational convenience we drop the subscript k and consider calculation of E X∼qx,τ (X). (5.1) In our numerical experiments we will approximate these expectations using stochastic gradient Langevin dynamics and importance sampling.Both methods are reviewed in the next two subsections.

Stochastic Gradient Langevin Dynamics
The first method that we use to approximate the expectation 5.1 -and thus the best-Gaussian approximation for local entropy optimization-is stochastic gradient Langevin dynamics (SGLD).The algorithm was introduced in [19] and its use for local entropy minimization was investigated in [4].The SGLD algorithm is summarized below.

Algorithm 3
Input: Sample size J and temperatures { j } J j=1 .1. Define x 0 = x.2. For j = 1,...,J − 1 do: When the function f is defined by a large sum over training data, minibatches can be used in the evaluation of the gradients ∇f (x j ).In our numerical experiments we initialize the Langevin chain at the last iteration of the previous parameter update.Note that SGLD can be thought of as a modification of gradient-based Metropolis-Hastings Markov chain Monte Carlo algorithms, where the accept-reject mechanism is replaced by a suitable tempering of the temperatures j .

Importance Sampling
We will also investigate the use of importance sampling [14] to approximate the expectations (5.1); our main motivation in doing so is to avoid gradient computations, and hence to give an example of a training scheme that does not involve back propagation.
Importance sampling is based on the observation that , and an approximation of the right-hand side may be obtained by standard Monte Carlo approximation of the numerator and the denominator.Crucially, these Monte Carlo simulations are performed sampling the Gaussian ϕ x,τ rather than the original density q.The importance sampling algorithm is then given by: Algorithm 4 Input: sample size J.
1. Sample {x j } J j=1 from the Gaussian density ϕ x,τ .2. Compute (unnormalized) weights w j = exp −f (x j ) .Output: approximation E X∼qx,τ (X) ≈ J j=1 w j x j J j=1 w j . (5.2) Importance sampling is easily parallelizable.If L processors are available, then each of the processors can be used to produce an estimate using J/L Gaussian samples, and the associated estimates can be subsequently consolidated.
While the use of importance sampling opens an avenue for gradient-free, parallelizable training of neural networks, our numerical experiments will show that naive implementation without parallelization gives poor performance relative to SGLD or plain stochastic gradient descent (SGD) descent on the original loss.A potential explanation is the so-called curse of dimension for importance sampling [18], [1].Another explanation is that the iterative structure of SGLD allows to re-utilize the previous parameter update to approximate the following one while importance sampling does not afford such iterative updating.Finally, SGLD with minibatches is known to asymptotically produce unbiased estimates, while the introduction of minibatches in importance sampling introduces a bias.

Minimization of
x → D KL (ϕ x,τ q x k ,τ ) A direct calculation shows that the preconditioned Euler-Lagrange equation for minimizing x → D KL (ϕ x,τ q x k ,τ ) is given by Here h(x) is implicitly defined as an expected value with respect to a distribution that depends on the parameter x.The Robbins-Monro algorithm [17] allows to estimate zeroes of functions defined in such a way.
The Robbins-Monro approach to computing the Gaussian approximation (x,τ ) → D KL (ϕ x,τ q x k ,τ ) in Hilbert space was studied in [16].A suitable choice for the step size is a l = cl α , for some c > 0 and α ∈ (1/2,1].Note that Algorithm 5 gives a form of spatially-averaged gradient descent, which involves repeated evaluation of the gradient of the original loss.The use of temporal gradient averages has also been studied as a way to reduce the noise level of stochastic gradient methods [3].To conclude we remark that an alternative approach could be to employ Robbins-Monro directly to optimize F H (x). Gradient calculations would still be needed.

Numerical Experiments
In the following numerical experiments we investigate the practical use of local entropy and heat regularization in the training of neural networks.We present experiments on dense multilayered networks applied to a basic image classification task, viz.MNIST [12].We implement Algorithms 3, 4, and 5 in TensorFlow, analyzing the effectiveness of each in comparison to stochastic gradient descent (SGD).We investigate whether the theoretical monotonicity of regularized losses translates into monotonicity of the held-out test data error.Additionally, we explore various choices for the hyper-parameter τ to illustrate the effects of variable levels of regularization.In accordance to the algorithms specified above, we employ importance sampling (IS) and stochastic gradient Langevin dynamics (SGLD) to approximate the expectation in (5.1), and the Robbins-Monro algorithm for heat regularization (HR).

Network Specification
Our experiments are carried out using the following networks: 1. Small Dense Network: Consisting of an input layer with 784 units and a 10 unit output layer, this toy network contains 7850 total parameters and achieves a test accuracy of 91.2 % when trained with SGD for 5 epochs over the 60,000 image MNIST dataset.2. Single Hidden Layer Dense Network: Using the same input and output layer as the smaller network with an additional 200 unit hidden layer, this network provides an architecture with 159,010 parameters.We expect this architecture to achieve a best-case performance of 98.9 % accuracy on MNIST, trained over the same data as the previous network.

Training Neural Networks From Random Initialization
Considering the computational burden of computing a Monte Carlo estimate for each weight update, we propose that Algorithms 3, 4, and 5 are potentially most useful when employed following SGD; although per-update progress is on par or exceeds that of SGD with step size, often called learning rate, equivalent to the value of τ , the computational load required makes the method unsuited for end-to-end training.Though in this section we present an analysis of these algorithms used for the entirety of training, this approach is likely too expensive to be practical for contemporary deep networks.Table 6.1 and the associated Figure 6.1 demonstrate the comparative training behavior for each algorithm, displaying the held-out test accuracy for identical instantiations of the hidden layer network trained with each algorithm for 500 parameter updates.Note that a mini-batch size of 20 was used in each case to standardize the amount of training data available to the methods.Additionally, SGLD, IS, and HR each employed While SGD, SGLD, and HR utilize gradient information in performing parameter updates, IS does not.This difference in approach contributes to IS's comparatively poor start; as the other methods advance quickly due to the large gradient of the loss landscape, IS's progress is isolated, leading to training that depends only on the choice of τ .When τ is held constant, as shown in 6.1, the rate of improvement remains nearly constant throughout.This suggests the need for dynamically updating τ , as is commonly performed with annealed learning rates for SGD.Moreover, SGD, SGLD and HR are all schemes that depend linearly in f , making mini-batching justifiable, something that is not true for IS.
It is worth noting that the time to train differed drastically between methods.Table 6.2 shows the average runtime of each algorithm in seconds.SGD performs roughly 10 3 times faster than the others, an expected result considering the most costly operation in training, filling the network weights, is performed 10 3 times per parameter  update.Other factors contributing to the runtime discrepancy are the implementation specifications and the deep learning library; here, we use TensorFlow's implementation of SGD, a method for which the framework is optimized.More generally, the runtimes in Table 6.2 reflect the hyper-parameter choices for the number of Monte Carlo samples, and will vary according to the number of samples considered.

Local Entropy Regularization after SGD
Considering the longer runtime of the sampling based algorithms in comparison to SGD, it is appealing to utilize SGD to train networks initially, then shift to more computationally intensive methods to identify local minima with favorable generaliza-tion properties.Figure 6.2 illustrates IS and SGLD performing better than HR when applied after SGD.HR's smooths the loss landscape, a transformation which is advantageous for generating large steps early in training, but presents challenges as smaller features are lost.In Figure 6.2, this effect manifests as constant test accuracy after SGD, and no additional progress is made.The contrast between each method is notable since the algorithms use equivalent step sizes-this suggests that the methods, not the hyper-parameter choices, dictate the behavior observed.
Presumably, SGD trains the network into a sharp local minima or saddle point of the non-regularized loss landscape; transitioning to an algorithm which minimizes the local entropy regularized loss then finds an extrema which performs better on the test data.However, based on our experiments, in terms of held-out data accuracy regularization in the later stages does not seem to provide significant improvement over training with SGD on the original loss.

Algorithm Stability & Monotonicity
Prompted by the guarantees of theorems 3.2 and 4.2 which prove the effectiveness of these methods when E X∼q (X) is approximated accurately, we also demonstrate the stability of these algorithms in the case of an inaccurate estimate of the expectation.To do so, we explore the empirical consequences of varying the number of samples used in the Monte Carlo and Robbins-Monro calculations.Figure 6.3 shows how each algorithm responds to this change.We observe that IS performs better as we refine our estimate of E X∼q (X), exhibiting less noise and faster training rates.This finding suggests that a highly parallel implementation of IS which leverages modern GPU architecture to efficiently compute the relevant expectation may offer practicality.SGLD also benefits from a more accurate approximation, displaying faster convergence and higher final testing accuracy when comparing 10 and 100 Monte Carlo samples.HR however performs more poorly when we employ longer Robbins-Monro chains, suffering from diminished step size and exchanging quickly realized progress for less oscillatory testing accuracy.Exploration of the choices of j and a j for SGLD and HR remains a valuable avenue for future research, specifically in regards to the interplay between these hyper-parameters and the variable accuracy of estimating E X∼q (X).

Choosing τ
An additional consideration of these schemes is the choice of τ , the hyper-parameter which dictates the level of regularization in Algorithms 3, 4, and 5.As noted in [4], large values of τ correspond to a nearly uniform local entropy regularized loss, whereas small values of τ yield a minimally regularized loss which is very similar the original loss function.To explore the effects of small and large values of τ , we train our smaller network with IS and SGLD for many choices of τ , observing how regularization alters training rates.
The results, presented in Figure 6.4,illustrate differences in SGLD and IS, particularly in the small τ regime.As evidenced in the leftmost plots, SGLD trains successfully, albeit slowly, with τ ∈ [0.001,0.01].For small values of τ , the held-out test accuracy improves almost linearly over parameter updates, appearing characteristically similar to SGD with a small learning rate.IS fails for small τ , with highly variant test accuracy improving only slightly during training.Increasing τ , we observe SGLD reach a point of saturation, as additional increases in τ do not affect the training trajectory.We note that this behavior persists as τ → ∞, recognizing that the regularization term in the SGLD algorithm approaches a value of zero for growing τ .IS demonstrates improved training efficiency in the bottom-center panel, showing that increased τ provides favorable algorithmic improvements.This trend dissipates for larger τ , with IS performing poorly as τ → ∞.The observed behavior suggests there exists an optimal τ which is architecture and task specific, opening opportunities to further develop a heuristic to tune the hyper-parameter.

Scoping of τ
As suggested in [4], we anneal the scope of τ from large to small values in order to examine the landscape of the loss function at different scales.Early in training, we use comparatively large values to ensure broad exploration, transitioning to smaller values for a comprehensive survey of the landscape surrounding a minima.We use the following schedule for the k th parameter update: where τ 0 is large and τ 1 is set so that the magnitude of the local entropy gradient is roughly equivalent to that of SGD.
As shown in Figure 6.5, annealing τ proves to be useful, and provides a method by which training can focus on more localized features to improve test accuracy.We observe that SGLD, with a smaller value of τ = 0.01, achieves a final test accuracy close to that of SGD, whereas τ = 1.5 is unable to identify the optimal minima.Additionally, the plot shows that large τ SGLD trains faster than SGD in the initial 100 parameter updates, whereas small τ SGLD lags behind.When scoping τ we consider both annealing and reverse-annealing, illustrating that increasing τ over training produces a network which trains more slowly than SGD and is unable to achieve testing accuracy comparable to that of SGD.Scoping τ from 1.5 → 0.01 via the schedule 6.5.1 with τ 0 = 1.5 and τ 1 = 0.01 delivers advantageous results, yielding an algorithm which trains faster than SGD after initialization and achieves analogous testing accuracy.

Fig. 2 . 1 :
Fig. 2.1: Toy example of local entropy regularization for a two dimensional lost function.Note how the wider minima from the left figure deepens on the right, while the sharp minima become relatively shallower.

Fig. 2 . 2 :
Fig. 2.2: Toy example of heat regularization for a two dimensional loss function.Here the smoothing via convolution with a Gaussian amounts to a blur, altering the texture of the landscape without changing the location of deep minima.

Fig. 5 . 1 :
Fig. 5.1: Cartoon representation of the mode-seeking (left) and mean-seeking (right) Kullback-Leibler minimization.Mean-seeking minimization is employed within localentropy optimization; mode-seeking minimization is employed within optimization of the heat-regularized loss.

Fig. 6 . 2 :
Fig. 6.2: Training after SGD, τ = 0.01 for all algorithms.The step size for the SGD is set equal to the value of τ for all three algorithms.SGLD temperatures are j = 1 2000+j , and HR uses the same update schedule as in Figure 6.1.

Table 6 .
1: Classification Accuracy on Held-Out Test Data