LipschitzLR: Using theoretically computed adaptive learning rates for fast convergence

TL;DR

This paper introduces LipschitzLR, a method for dynamically computing adaptive learning rates for deep neural network training based on the Lipschitz constant, leading to faster convergence and better hyper-parameter tuning.

Contribution

The paper presents a theoretical framework for calculating learning rates using Lipschitz constants and extends it to various optimization algorithms, improving training efficiency.

Findings

Adaptive learning rates computed via Lipschitz constants outperform fixed rates.

Commonly used learning rates are significantly smaller than the theoretically optimal values.

The approach accelerates convergence across multiple architectures and datasets.

Abstract

Optimizing deep neural networks is largely thought to be an empirical process, requiring manual tuning of several hyper-parameters, such as learning rate, weight decay, and dropout rate. Arguably, the learning rate is the most important of these to tune, and this has gained more attention in recent works. In this paper, we propose a novel method to compute the learning rate for training deep neural networks with stochastic gradient descent. We first derive a theoretical framework to compute learning rates dynamically based on the Lipschitz constant of the loss function. We then extend this framework to other commonly used optimization algorithms, such as gradient descent with momentum and Adam. We run an extensive set of experiments that demonstrate the efficacy of our approach on popular architectures and datasets, and show that commonly used learning rates are an order of magnitude smaller than the ideal value.

Figures

Tables

Table 1. Table 1 : Comparison of speed of convergence with α = 0.1 𝛼 0.1 \alpha=0.1 and α = 1 L 𝛼 1 𝐿 \alpha=\frac{1}{L} . The speed of convergence under the influence of adaptive learning rate, α = 1 L 𝛼 1 𝐿 \alpha=\frac{1}{L} is evident. L 𝐿 L is the Lipschitz constant.

Dataset	$T_L$	$1/L$	$E_{0.1}$	$E_{1/L}$
Boston housing prices	200	9.316	46,041	555
California housing prices	2.8051	5163.5	24,582	2
Energy efficiency [43]	100	12.78	489,592	3,833
Online news popularity [8]	73,355,000	1.462	10,985	753
Breast cancer	0.69	4280.23	37,008	2
Covertype333We restricted the data to the first 100K rows only.	0.69314	17.48M	216,412	2
Iris	0.2	1.902	413	49
Digits	0.2	0.634	337	2

Table 2. Table 2 : Comparison of performance with α = 0.1 𝛼 0.1 \alpha=0.1 and α = 1 L 𝛼 1 𝐿 \alpha=\frac{1}{L} . A 1 / L subscript 𝐴 1 𝐿 A_{1/L} denotes adaptive learning rate proposed in the paper.

Dataset	$N_E$	$1/L$	$A_{0.1}$	$A_{1/L}$
Iris	200	1.936	93.33%	97.78%
Digits	200	0.635	91.3%	94.63%
MNIST	200	10.24	92.7%	92.8%
Cover Type444The inverse Lipschitz constant is different here because the number of rows was not restricted to 100K. Also, the inverse Lipschitz constant here is not a typo. The learning rate was indeed set to 189.35 million.	1000	189.35M	43.05%	57.21%
Breast cancer	1000	4280.22	43.23%	90.5%

Table 3. Table 3 : Summary of all experiments: abbreviations used - LR: Learning Rate; WD: weight decay; VA: validation accuracy

Dataset	Architecture	Algorithm	LR Policy	WD	VA.
MNIST	Custom	SGD	Adaptive	None	99.5%
MNIST	Custom	Momentum	Adaptive	None	99.57%
MNIST	Custom	Adam	Adaptive	None	99.43%
CIFAR-10	ResNet20	SGD	Baseline	${10}^{-3}$	60.33%
CIFAR-10	ResNet20	SGD	Fixed	${10}^{-3}$	87.02%
CIFAR-10	ResNet20	SGD	Adaptive	${10}^{-3}$	89.37%
CIFAR-10	ResNet20	Momentum	Baseline	${10}^{-3}$	58.29%
CIFAR-10	ResNet20	Momentum	Adaptive	${10}^{-2}$	84.71%
CIFAR-10	ResNet20	Momentum	Adaptive	${10}^{-3}$	89.27%
CIFAR-10	ResNet20	RMSprop	Baseline	${10}^{-3}$	84.92%
CIFAR-10	ResNet20	RMSprop	Adaptive	${10}^{-3}$	86.66%
CIFAR-10	ResNet20	Adam	Baseline	${10}^{-3}$	84.67%
CIFAR-10	ResNet20	Adam	Fixed	${10}^{-4}$	70.57%
CIFAR-10	DenseNet	SGD	Baseline	${10}^{-4}$	84.84%
CIFAR-10	DenseNet	SGD	Adaptive	${10}^{-4}$	91.34%
CIFAR-10	DenseNet	Momentum	Baseline	${10}^{-4}$	85.50%
CIFAR-10	DenseNet	Momentum	Adaptive	${10}^{-4}$	92.36%
CIFAR-10	DenseNet	RMSprop	Baseline	${10}^{-4}$	91.36%
CIFAR-10	DenseNet	RMSprop	Adaptive	${10}^{-4}$	90.14%
CIFAR-10	DenseNet	Adam	Baseline	${10}^{-4}$	91.38%
CIFAR-10	DenseNet	Adam	Adaptive	${10}^{-4}$	88.23%
CIFAR-100	ResNet56	SGD	Adaptive	${10}^{-3}$	54.29%
CIFAR-100	ResNet164	SGD	Baseline	${10}^{-4}$	26.96%
CIFAR-100	ResNet164	SGD	Adaptive	${10}^{-4}$	75.99%
CIFAR-100	ResNet164	Momentum	Baseline	${10}^{-4}$	27.51%
CIFAR-100	ResNet164	Momentum	Adaptive	${10}^{-4}$	75.39%
CIFAR-100	ResNet164	RMSprop	Baseline	${10}^{-4}$	70.68%
CIFAR-100	ResNet164	RMSprop	Adaptive	${10}^{-4}$	70.78%
CIFAR-100	ResNet164	Adam	Baseline	${10}^{-4}$	71.96%
CIFAR-100	DenseNet	SGD	Baseline	${10}^{-4}$	50.53%
CIFAR-100	DenseNet	SGD	Adaptive	${10}^{-4}$	68.18%
CIFAR-100	DenseNet	Momentum	Baseline	${10}^{-4}$	52.28%
CIFAR-100	DenseNet	Momentum	Adaptive	${10}^{-4}$	69.18%
CIFAR-100	DenseNet	RMSprop	Baseline	${10}^{-4}$	65.41%
CIFAR-100	DenseNet	RMSprop	Adaptive	${10}^{-4}$	67.30%
CIFAR-100	DenseNet	Adam	Baseline	${10}^{-4}$	66.05%
CIFAR-100	DenseNet	Adam	Adaptive	${10}^{-4}$	40.14%555This was obtained after 67 epochs. After that, the performance deteriorated, and after 170 epochs, we stopped running the model. We also ran the model on the same architecture, but restricting the number of filters to 12, which yielded 59.08% validation accuracy.

Table 4. Table 4 : CNN used for MNIST

Layer	Filters	Padding
3 x 3 Conv	32	Valid
3 x 3 Conv	32	Valid
2 x 2 MaxPool	–	–
Dropout (0.2)	–	–
3 x 3 Conv	64	Same
3 x 3 Conv	64	Same
2 x 2 MaxPool	–	–
Dropout (0.25)	–	–
3 x 3 Conv	128	Same
Dropout (0.25)	–	–
Flatten	–	–
Dense (128)	–	–
BatchNorm	–	–
Dropout (0.25)	–	–
Dense (10)	–	–

Table 5. Table 5 : Comparison of ResNets on CIFAR-10 between AdaShift and LipschitzLR.

Training Details	AdaShift	LipschitzLR	LipschitzLR (custom)
Architecture	ResNet18	ResNet 20	DenseNet-40
Epochs	50	300	300
Validation accuracy	91.25%	89.37%	92.36%

Table 6. Table 6 : Comparison of DenseNets on CIFAR-10 between AdaShift and LipschitzLR. The DenseNet with AdaMo yields our best results on CIFAR-10.

Training Details	AdaShift	LipschitzLR
Architecture	100-layer DenseNet	40-layer DenseNet
Epochs	150	300
Validation accuracy	90%	91.34% (SGD), 92.36% (AdaMo)

Table 7. Table 7 : Comparison of neural networks on MNIST between AdaShift and LipschitzLR.

Training Details	AdaShift	LipschitzLR
Architecture	2 hidden layers	16 layers as in Table 4
Epochs	20	20
Validation accuracy	89%	99.5% (SGD), 99.57% (AdaMo)

Table 8. Table 8 : Comparison of networks on MNIST between AdaDelta and LipschitzLR.

Training Details	AdaDelta	LipschitzLR
Architecture	2-layer network with tanh activations	CNN described in Table 4
Epochs	6	20
Validation accuracy	98.17%	99.5% (SGD), 99.57% (AdaMo)

Table 9. Table 9 : Comparison of ResNets on CIFAR-10 between WN-Adam and LipschitzLR.

Training Details	WN-Adam	LipschitzLR	LipschitzLR (custom)
Architecture	ResNet18	ResNet 20	DenseNet-40
Epochs	100	300	300
Validation accuracy	92%	89.37%	92.36%

Table 10. Table 10 : Comparison of ResNets on CIFAR-10 between AMSGrad and LipschitzLR.

Training Details	AMSGrad	LipschitzLR	LipschitzLR (custom)
Architecture	ResNet 18	ResNet 20	DenseNet-40
Epochs	50	300	300
Validation accuracy	90%	89.37%	92.36%

Table 11. Table 11 : Comparison of DenseNets on CIFAR-10 between AMSGrad and LipschitzLR.

Training Details	AMSGrad	LipschitzLR
Architecture	DenseNet-100	DenseNet-40
Epochs	150	300
Validation accuracy	88.75%	91.34% (SGD), 92.36% (AdaMo)

Table 12. Table 12 : Comparison of networks on MNIST between AMSGrad and LipschitzLR.

Training Details	AMSGrad	LipschitzLR
Architecture	2-layer network	CNN described in Table 4
Epochs	20	20
Validation accuracy	89%	99.5% (SGD), 99.57% (AdaMo)

Equations

$$\text{w}:=\text{w}-\alpha \cdot {\nabla }_{\text{w}}f$$

$$\Vert f({\text{w}}_1)-f({\text{w}}_2)\Vert \le L\Vert {\text{w}}_1-{\text{w}}_2\Vert$$

$$\Vert f({\text{w}}_1)-f({\text{w}}_2)\Vert$$

$$\le \underset{\text{v}}{\sup }\Vert {\nabla }_{\text{w}}f(\text{v})\Vert \Vert {\text{w}}_1-{\text{w}}_2\Vert$$

$$L\le \underset{\text{v}}{\sup }\Vert {\nabla }_{\text{w}}f(\text{v})\Vert$$

$${\mathbf{w}}^{\mathbf{k}+1}={\mathbf{w}}^{\mathbf{k}}-{\eta }_k{\nabla }_{w}f$$

$${\mathbf{v}}^{\mathbf{T}}{\nabla }^2\mathbf{f}(\mathbf{u})\mathbf{v}\le {\mathbf{v}}^{\mathbf{T}}(L\mathbf{I})\mathbf{v}=>{\mathbf{v}}^{\mathbf{T}}{\nabla }^2\mathbf{f}(\mathbf{u})\mathbf{v}\le L{\Vert \mathbf{v}\Vert }^2$$

$$\mathbf{f}(\mathbf{v})=\mathbf{f}(\mathbf{w})+\nabla \mathbf{f}(\mathbf{w}{)}^{\mathbf{T}}(\mathbf{v}-\mathbf{w})+\frac{1}{2}(\mathbf{v}-\mathbf{w}{)}^T{\nabla }^2\mathbf{f}(\mathbf{w})(\mathbf{v}-\mathbf{w})$$

$$\mathbf{f}(\mathbf{v})\le \mathbf{f}(\mathbf{w})+\nabla \mathbf{f}(\mathbf{w}{)}^{\mathbf{T}}(\mathbf{v}-\mathbf{w})+\frac{L}{2}{\Vert \mathbf{v}-\mathbf{w}\Vert }^2$$

$$\mathbf{f}({\mathbf{w}}^{\mathbf{k}+1})\le \mathbf{f}({\mathbf{w}}^{\mathbf{k}})+\nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}}{)}^{\mathbf{T}}({\mathbf{w}}^{\mathbf{k}+1}-{\mathbf{w}}^{\mathbf{k}})+\frac{L}{2}{\Vert {\mathbf{w}}^{\mathbf{k}+1}-{\mathbf{w}}^{\mathbf{k}}\Vert }^2$$

$$\mathbf{f}({\mathbf{w}}^{\mathbf{k}+1})\le \mathbf{f}({\mathbf{w}}^{\mathbf{k}})-\frac{1}{L}\nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}}{)}^{\mathbf{T}}\nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})+\frac{L}{2}{\Vert \frac{-1}{L}\nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2$$

$$\mathbf{f}({\mathbf{w}}^{\mathbf{k}+1})\le \mathbf{f}({\mathbf{w}}^{\mathbf{k}})-\frac{1}{L}{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2+\frac{1}{2L}{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2$$

$$\mathbf{f}({\mathbf{w}}^{\mathbf{k}+1})\le \mathbf{f}({\mathbf{w}}^{\mathbf{k}})-\frac{1}{2L}{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2$$

$${\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2\le 2L(\mathbf{f}({\mathbf{w}}^{\mathbf{k}})-\mathbf{f}({\mathbf{w}}^{\mathbf{k}+1}))$$

$$\sum _{k=1}^n{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2\le 2L\sum _{k=1}^n(\mathbf{f}({\mathbf{w}}^{\mathbf{k}})-\mathbf{f}({\mathbf{w}}^{\mathbf{k}+1}))$$

$$\sum _{k=1}^n{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2\le 2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\mathbf{n}+1}))$$

$$\sum _{k=1}^n\underset{j\in 1,2,..n}{\min }{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{j}})\Vert }^2\le \sum _{k=1}^n{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{k}})\Vert }^2$$

$$\sum _{k=1}^n\underset{j\in 1,2,..n}{\min }{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{j}})\Vert }^2\le 2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\mathbf{n}+1}))$$

$$n\underset{j\in 1,2,..n}{\min }{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{j}})\Vert }^2\le 2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\mathbf{n}+1}))$$

$$n\underset{j\in 1,2,..n}{\min }{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{j}})\Vert }^2\le 2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\ast }))\text{where}f(w^{\ast })<f(w^{n+1})$$

$$\underset{j\in 1,2,..n}{\min }{\Vert \nabla \mathbf{f}({\mathbf{w}}^{\mathbf{j}})\Vert }^2\le \frac{2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\ast }))}{n}=O(\frac{1}{n})$$

$$\frac{2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\ast }))}{n}\le ϵ$$

$$n\ge \frac{2L(\mathbf{f}({\mathbf{w}}^0)-\mathbf{f}({\mathbf{w}}^{\ast }))}{ϵ}$$

$$\Vert f(\text{x})-f(\text{y})\Vert \le L\Vert \text{x}-\text{y}\Vert$$

$$\frac{\Vert f(\text{x})-f(\text{y})\Vert }{\Vert \text{x}-\text{y}\Vert }\le L$$

$$\underset{h,k}{\max }\Vert \frac{\partial E}{\partial w_{hk}^{[L]}}\Vert \ge \Vert \frac{\partial E}{\partial w_{ij}^{[l]}}\Vert \forall l,i,j$$

$$z^{[l]}$$

$$a^{[l]}$$

$$a^{[0]}$$

$$\frac{\partial E}{\partial w_{ij}^{[L]}}$$

$$=\frac{\partial E}{\partial a_j^{[L]}}\cdot \frac{\partial a_j^{[L]}}{\partial z_j^{[L]}}\cdot a_i^{[L-1]}$$

$$\underset{i,j}{\max }\left|\frac{\partial E}{\partial w_{ij}^{[L]}}\right|\le \underset{j}{\max }\left|\frac{\partial E}{\partial a_j^{[L]}}\right|\cdot \underset{j}{\max }\left|\frac{\partial a_j^{[L]}}{\partial z_j^{[L]}}\right|\cdot \underset{j}{\max }\left|a_j^{[L-1]}\right|$$

$$g(\text{w})=\frac{1}{2m}\sum _{i=1}^m{\left({\text{x}}^{(i)}\text{w}-y^{(i)}\right)}^2$$

$$g(\text{w})-g(\text{v})$$

$$=\frac{1}{2m}\sum _{i=1}^m\left({\text{x}}^{(i)}(\text{w}+\text{v})-2y^{(i)}\right)\left({\text{x}}^{(i)}(\text{w}-\text{v})\right)$$

$$=\frac{1}{2m}\sum _{i=1}^m\left((\text{w}+\text{v}{)}^T{\text{x}}^{(i)T}-2y^{(i)}\right)\left({\text{x}}^{(i)}(\text{w}-\text{v})\right)$$

$$=\frac{1}{2m}\sum _{i=1}^m\left((\text{w}+\text{v}{)}^T{\text{x}}^{(i)T}{\text{x}}^{(i)}-2y^{(i)}{\text{x}}^{(i)}\right)(\text{w}-\text{v})$$

$$\boxed{\frac{\Vert g(\text{w})-g(\text{v})\Vert }{\Vert \text{w}-\text{v}\Vert }\le \frac{K}{m}\Vert {\text{X}}^T\text{X}\Vert +\frac{1}{m}\Vert {\text{y}}^T\text{X}\Vert }$$

Full text

1 Introduction

Gradient descent[6] is a popular optimization algorithm for finding optima for functions, and is used to find optima in loss functions in machine learning tasks. In an iterative process, it seeks to update randomly initialized weights to minimize the training error. These updates are typically small values proportional to the gradient of the loss function. The constant of proportionality is called the learning rate, and is usually manually chosen in the gradient descent rule.

When optimizing a function $f$ with respect to a parameter w, the gradient descent update rule is given by

[TABLE]

The generalization ability of stochastic gradient descent (SGD) and various methods of faster optimization have quickly gained interest in machine learning and deep learning communities.

Several directions have been taken to understand these phenomena. The interest in the stability of SGD is one such direction[22] [14]. Others have proven that gradient descent can find the global minima of the loss functions in over-parameterized deep neural networks [49] [7].

More practical approaches in this regard have involved novel changes to the optimization procedure itself. These include adding a “momentum” term to the update rule [39], and “adaptive gradient” methods such as RMSProp[42], and Adam[20]. These methods have seen widespread use in deep neural networks[27] [45] [1]. Other methods rely on an approximation of the Hessian. These include the Broyden-Fletcher-Goldfarb-Shanno (BFGS) [5] [9] [12] [32] and L-BFGS[23] algorithms. However, our proposed method does not require any modification of the standard gradient descent update rule, and only schedules the learning rate. Furthermore, for classical machine learning models, this learning rate is fixed and thus, our approach does not take any extra time. In addition, we only use the first gradient, thus requiring functions to be only once differentiable and $L$-Lipschitz.

Recently, several adaptive learning rate methods have been proposed. Zeiler [46] proposed AdaDelta, a per-dimension learning rate scheme that relies on computing the Hessian of the loss function. Zhou et al. [48] propose AdaShift, an improvement over the Adam algorithm. Wu et al. [44] propose WNGrad, an adaptive learning rate based on weight normalization. Reddi et al. [28] propose AMSGrad improve upon Adam by incorporating long-term memory into the update. Luo et al. [24] propose AdaBound and AMSBound, which rely on estimating the moment to find an adaptive learning rate.

However, we note several issues with the above approaches. For example, several methods rely on computing the Hessian of the loss function, which can be computationally expensive, and is typically estimated, using methods (for an example of such a method, see Martens et al. [25]). In addition, a general trend that can be observed is to improve upon previous algorithms such as Adam. Finally, some of the methods above are specifically tuned for neural networks, and as such, are limited to deep learning.

Our approach alleviates the issues discussed above. Because our approach does not rely on computing the Hessian, it is computationally cheaper. Computing the first order derivatives (which is a significantly weaker condition to hold for commonly used loss functions) suffices for our approach. Further, as will be discussed in Section 9, modern frameworks include functions that allow us to compute our lipschitz adaptive learning rate in a significantly faster way. Our approach is also algorithm-independent; we describe our adaptive learning rate approach for SGD, SGD with momentum, and Adam. Further, while Wu et al. [44] note that ”Thus in the stochastic setting, there is no ’best choice’ for the learning rate”, we disagree. Our learning rate is computed taking the mini-batch data into consideration, and therefore is truly adaptive in that it is tailored to each mini-batch. Finally, we argue in this paper that larger learning rates than typically used can work well, in agreement with Smith and Topin [36].

1.1 Deep learning

Deep learning [13] is becoming more omnipresent for several tasks, including image recognition and classification [33] [40] [31] [47], face recognition [41], and object detection [10], even surpassing human-level performance[15]. At the same time, the trend is towards deeper neural networks [19] [15].

Despite their popularity, training neural networks is made difficult by several problems. These include vanishing and exploding gradients [11] [4] and overfitting. Various advances including different activation functions [21] [26], batch normalization [19], novel initialization schemes [15], and dropout [37] offer solutions to these problems.

However, a more fundamental problem is that of finding optimal values for various hyperparameters, of which the learning rate is arguably the most important. It is well-known that learning rates that are too small are slow to converge, while learning rates that are too large cause divergence [3]. Recent works agree that rather than a fixed learning rate value, a non-monotonic learning rate scheduling system offers faster convergence [30] [34]. It has also been argued that the traditional wisdom that large learning rates should not be used may be flawed, and can lead to “super-convergence” and have regularizing effects [36]. Our experimental results agree with this statement; however, rather than use cyclical learning rates based on intuition, we propose a novel method to compute an adaptive learning rate backed by theoretical foundations.

Recently, there has been a lot of work on finding novel ways to adaptively change the learning rate. These have both theoretical [30] and intuitive, empirical [36] [34] backing. These works rely on non-monotonic scheduling of the learning rate. [34] argues for cyclical learning rates. Our proposed method also yields a non-monotonic learning rate, but does not follow any predefined shape.

2 Our Contribution

In this paper, we propose a novel theoretical framework to compute large, adaptive learning rates for use in gradient-based optimization algorithms. We start with a presentation of the theoretical framework and the motivation behind it, and then derive the mathematical formulas to compute the learning rate on each epoch. We then extend our approach from stochastic gradient descent (SGD) to other optimization algorithms. Finally, we present extensive experimental results to support our claims.

Our experimental results show that compared to standard choices of learning rates, our approach converges quicker and achieves better results. During the experiments, we explore cases where adaptive learning rates outperform fixed learning rates. Our approach exploits functional properties of the loss function, and only makes two minimal assumptions on the loss function: it must be Lipschitz continuous[29] and (at least) once differentiable. Commonly used loss functions satisfy both these properties.

In summary, our contributions in this paper are as follows:

• •

We present a theoretical framework based on the Lipschitz constant of the loss function to compute an adaptive learning rate.

• •

We provide an intuitive motivation and mathematical justification for using the inverse of the Lipschitz constant as the learning rate in gradient-based optimization algorithms, and derive formulas for the Lipschitz constant of several commonly used loss functions. We note that classical machine learning models, such as logistic regression, are simply special cases of deep learning models, and show the equivalence of the formulas derived.

• •

We argue that the use of Lipschitz constants to determine learning rate accelerates convergence many-fold in comparison with standard learning rate choices. We present empirical evidence of our claims in Section 6. This is a departure from the approach of manually tuning learning rates.

• •

Through extensive experimentation, we demonstrate the strength of our results with both classical machine learning models and deep learning models.

The rest of the paper is organized as follows. The paper begins with our theoretical framework based on the properties of several loss functions, in Section 3. Section 4 provides mathematical justification for setting the learning rate as the inverse of the Lipschitz constant and argues that such setting shall provide an estimate for number of iterations to converge to the global optima. Section 5 derives the Lipschitz constant for regression problems. Section 6 deals with derivation of learning rate in classification problems. In Section 7, we extend the framework to algorithms that extend SGD, such as RMSprop, momentum, and Adam. Section 8 details our experiments and discusses their results. Section 9 discusses some practical considerations of our approach. We conclude in section 10 with a brief discussion.

3 Theoretical Framework

3.1 Introduction and Motivation

For a function, the Lipschitz constant is the least positive constant $L$ such that

[TABLE]

for all $\textbf{w}_{1}$, $\textbf{w}_{2}$ in the domain of $f$. From the mean-value theorem for scalar fields, for any $\textbf{w}_{1},\textbf{w}_{2}$, there exists v such that

[TABLE]

Thus, $\sup\limits_{\textbf{v}}\left\lVert\nabla_{\textbf{w}}f(\textbf{v})\right\rVert$ is such an $L$. Since $L$ is the least such constant,

[TABLE]

In this paper, we use $\max\left\lVert\nabla_{\textbf{w}}f\right\rVert$ to derive the Lipschitz constants. Our approach makes the minimal assumption that the functions are Lipschitz continuous and differentiable up to first order only 111Note this is a weaker condition than assuming the gradient of the function being Lipschitz continuous. We exploit merely the boundedness of the gradient.. Because the gradient of these loss functions is used in gradient descent, these conditions are guaranteed to be satisfied.

By setting $\alpha=\frac{1}{L}$, we have $\Delta\textbf{w}\leq 1$, constraining the change in the weights. We stress here that we are not computing the Lipschitz constants of the gradients of the loss functions, but of the losses themselves. Therefore, our approach merely assumes the loss is $L$-Lipschitz, and not $\beta$-smooth. We argue that the boundedness of the effective weight changes makes it optimal to set the learning rate to the reciprocal of the Lipschitz constant. This claim, while rather bold, is supported by our experimental results.

4 Mathematical Justification of the Learning Rate Setting

A typical Gradient Descent algorithm is in the form of

[TABLE]

for $k\in\mathbb{Z}$ and stop if $\left\|\nabla_{w}f\right\|\leq\epsilon$

$\forall v,w,\exists L$ such that $\left\|f(\textbf{v})-f(\textbf{w})\right\|\leq L\left\|\textbf{v}-\textbf{w}\right\|$. The assumption that gradients cannot change arbitrarily fast is fairly weak. So, for $f\in C^{2}$, the Lipschitz condition can be written as $\nabla^{2}f(w)\leq LI$, where $I$ represents the Identity matrix and $L$ be the Lipschitz constant (Note, for scalar functions, $f\in C^{2},\nabla^{2}f(w)\leq L$). $\nabla^{2}f(w)\leq LI\implies$

[TABLE]

for any $u,v,w$ where $u$ is a convex combination of $v,w$. By the Taylor series and using (5),

[TABLE]

This provides a convex quadratic upper bound which can be minimized using gradient descent with the learning rate $\eta_{k}$ = $\frac{1}{L}$. Consider $\boldsymbol{w^{k+1}}=\boldsymbol{w^{k}}-\eta_{k}\nabla_{w}f$. Substituting $\boldsymbol{w^{k}}$ and $\boldsymbol{w^{k+1}}$ for $\boldsymbol{w}$ and $\boldsymbol{v}$ respectively in 6 and using 4, we obtain

[TABLE]

Therefore, Gradient Descent decreases $\boldsymbol{f(w)}$ if $\eta_{k}=\frac{1}{L}$ and $\eta_{k}<\frac{2}{L}$. This proof also enables one to derive the rate of convergence with Lipschitz adaptive learning rate.

4.1 Convergence rate

A choice of learning rate $\eta_{k}=\frac{1}{L}$ and $\eta_{k}<\frac{2}{L}$ ensures that $f(w)$ converges to a global optimum. In order to prove that, we must prove that $\left\|\nabla f(w^{k})\right\|\leq\epsilon$ such that the rate of convergence can be found. The following assumptions are made, which are consistent with the computation of Lipschitz constant- $\nabla f$ is Lipschitz continuous, the gradient descent rule follows a step size,$\eta_{k}=\frac{1}{L}$ and $f$ is bounded below. Most loss functions satisfy all of these properties.

Let $n$ represent the number of iterations. We know that,

[TABLE]

The RHS of the above inequality follows from a simple telescoping sum. Moreover, since

[TABLE]

It follows that,

[TABLE]

If,

[TABLE]

Therefore, Gradient Descent requires, at least, $n=O(\frac{1}{\epsilon})$ iterations to achieve the error bound: $\left\|\nabla f(w^{k})\right\|\leq\epsilon$ 222Since $f\in C^{2}$ is a condition for obtaining lower bound on the number of iterations to converge for the choice of Lipschitz learning rate, Mean Absolute Error can’t be used as loss function.

4.2 Significance of Lipschitz constant (LC)

The Lipschitz constant (LC) has found a variety of uses in computing and applications. The central condition to the existence and uniqueness of solutions to first order system of differential equations of the form $y^{\prime}(t)=f(t,y(t)$ is LC of $f$. The existence of LC guarantees contraction and eventually a fixed point i.e. solution to the above system[2] and saves the trouble of computing an analytical solution to the system above. Finding an LC is equivalent to to the fact that the function, $f$ possesses Lipschitz continuity. Given, $f:R\xrightarrow{}R,$ there exists an $L$ such that

[TABLE]

Consequently,

[TABLE]

This implies, the slope of the secant line connecting $x,y$ is bounded above. This is equivalent to stating that computing a LC of a function (loss function, in our case) is identical to computing the maximum of the derivative of $f$. This also establishes the relation between finding LC and the Mean Value Theorem. Note, however, that Lipschitz continuity is not synonymous to uniform continuity, a much stronger condition. For loss functions which are differentiable, we can easily compute LCs and therefore find the bound on the derivatives to be used in deep neural network training. Our paper focuses on loss functions that satisfy the conditions of differentiability and hence Lipschitz continuity. We compute LCs of those loss functions in the subsequent sections and arrive at adaptive learning rate formulation.

4.3 Notation

We use the following notation:

• •

$(x^{(i)},y^{(i)})$ refers to one training example. The superscript with parentheses indicates the $i$th training example. $X$ refers to the input matrix.

• •

Where not specified, it should be assumed that $m$ indicates the number of training examples.

• •

For deep neural networks, whenever unclear, we use a superscript with square brackets to indicate the layer number. For example, $W^{[l]}$ indicates the weight matrix at the $l$th layer. We use $L$ to represent the total number of layers, being careful not to cause ambiguity with the Lipschitz constant.

• •

We use the letter $w$ or $W$ to refer to weights, while $b$ refers to a bias term. Capital letters indicate matrices; lowercase letters indicate scalars, and are usually accompanied by subscripts–in such a case, we will adequately describe what the subscripts indicate.

• •

We use the letter $a$ to denote an activation; thus, $a^{[l]}$ represents the activations at the $l$th layer.

• •

Where not specified, the matrix norm is the Frobenius norm, and $\left\lVert z\right\rVert=z$ when $z\in\mathbb{R}$.

4.4 Deriving the Lipschitz constant for neural networks

For a neural network that uses the sigmoid, ReLU, or softmax activations, it is easily shown that the gradients get smaller towards the earlier layers in backpropagation. Because of this, the gradients at the last layer are the maximum among all the gradients computed during backpropagation. If $w^{[l]}_{ij}$ is the weight from node $i$ to node $j$ at layer $l$, and if $L$ is the number of layers, then

[TABLE]

Essentially, (7) says that the maximum gradient of the error with respect to the weights in the last layer is greater than the gradient of the error with respect to any weight in the network. In other words, finding the maximum gradient at the last layer gives us a supremum of the Lipschitz constants of the error, where the gradient is taken with respect to the weights at any layer. We call this supremum as a Lipschitz constant of the loss function for brevity.

We now analytically arrive at a theoretical Lipschitz constant for different types of problems. The inverse of these values can be used as a learning rate in gradient descent. Specifically, since the Lipschitz constant that we derive is an upper bound on the gradients, we effectively limit the size of the parameter updates, without necessitating an overly guarded learning rate. In any layer, we have the computations

[TABLE]

Thus, the gradient with respect to any weight in the last layer is computed via the chain rule as follows.

[TABLE]

This gives us

[TABLE]

The third part cannot be analytically computed; we denote it as $K_{z}$. We now look at various types of problems and compute these components. Note that we use the terms “cost function” and “loss function” interchangeably.

5 Least-squares cost function

For the least squares cost function, we will separately compute the Lipschitz constant for a linear regression model and for neural networks where the output is continuous. We will then prove the equivalence of the two results, deriving the former as a special case of the latter.

5.1 Linear regression

We have,

[TABLE]

Thus,

[TABLE]

The penultimate step is obtained by observing that $(\textbf{w}+\textbf{v})^{T}\textbf{x}^{(i)T}$ is a real number, whose transpose is itself.

At this point, we take the norm on both sides, and then assume that w and v are bounded such that $\left\|\textbf{w}\right\|,\left\|\textbf{v}\right\|\leq K$. Taking norm on both sides,

[TABLE]

We are forced to use separate norms because the matrix subtraction $2K\textbf{X}^{T}\textbf{X}-2\textbf{y}^{T}\textbf{X}$ cannot be performed. The RHS here is the Lipschitz constant. Note that the Lipschitz constant changes if the cost function is considered with a factor other than $\frac{1}{2m}$.

5.2 Regression with neural networks

Let the loss be given by

[TABLE]

where the vectors contain the values for each training example. Then we have,

[TABLE]

This gives us,

[TABLE]

where $K_{a}$ is the upper bound of $\left\lVert\textbf{a}\right\rVert$ and $\left\lVert\textbf{b}\right\rVert$. A reasonable choice of norm is the 2-norm.

Looking back at (12), the second term on the right side of the equation is the derivative of the activation with respect to its parameter. Notice that if the activation is sigmoid or softmax, then it is necessarily less than 1; if it is ReLu, it is either 0 or 1. Therefore, to find the maximum, we assume that the network is comprised solely of ReLu activations, and the maximum of this is 1.

From (12), we have

[TABLE]

5.3 Equivalence of the constants

The equivalence of the above two formulas is easy to see by understanding the terms of (15). We had defined in (12),

[TABLE]

Because a linear regression model can be thought of as a neural network with no hidden layers and a linear activation, and from (10), we have,

[TABLE]

and therefore

[TABLE]

Next, observe that $K_{a}$ is the upper bound of the final layer activations. For a linear regression model, we have the “activations” as the outputs: $\hat{\textbf{y}}=\textbf{W}^{T}\textbf{X}$. Using the assumption that $\left\lVert\textbf{W}\right\rVert$ has an upper bound $K$, we obtain

[TABLE]

Substituting (17) and (18) in (15), we obtain

[TABLE]

$\hfill\square$

This argument can also be used for the other loss functions that we discuss below; therefore, we will not prove equivalence of the Lipschitz constants for classical machine learning models (logistic regression and softmax regression) and neural networks. However, we will show experiments on both separately.

6 Classification

6.1 Binary classification

For binary classification, we use the binary cross-entropy loss function. Assuming only one output node,

[TABLE]

where $g(z)$ is the sigmoid function. We use a slightly different version of (12) here:

[TABLE]

Then, we have

[TABLE]

It is easy to show, using the second derivative, that this attains a maxima at $\textbf{z}^{[L]}=0$:

[TABLE]

Setting (22) to 0 yields $a^{[L-1]}_{j}=0\ \forall j$, and thus $z^{[L]}=W^{[L]}_{ij}a^{[L-1]}_{j}=0$. This implies $g(\textbf{z}^{[L]})=\frac{1}{2}$. Now whether y is 0 or 1, substituting this back in (21), we get

[TABLE]

Using (23) in (20),

[TABLE]

We simply mention here that for logistic regression, the Lipschitz constant is

[TABLE]

6.2 Multi-class classification

While conventionally, multi-class classification is done using one-hot encoded outputs, that is not convenient to work with mathematically. An identical form of this is to assume the output follows a Multinomial distribution, and then updating the loss function accordingly. This is because the effect of the typical loss function used is to only consider the “hot” vector; we achieve the same effect using the Iverson notation, which is equivalent to the Kronecker delta. With this framework, the loss function is

[TABLE]

Then the first part of (12) is trivial to compute:

[TABLE]

The second part is computed as follows.

[TABLE]

Combining (26) and (27) in (11) gives

[TABLE]

It is easy to show that the limiting case of this is when all softmax values are equal and each $y^{(i)}=p$; using this and $a^{[L]}_{p}=\frac{1}{k}$ in (28) and combining with (12) gives us our desired result:

[TABLE]

For a softmax regression model, we have

[TABLE]

6.3 Regularization

This framework is extensible to the case where the loss function includes a regularization term.

In particular, if an $L_{2}$ regularization term, $\frac{\lambda}{2}\left\|\textbf{w}\right\|_{2}^{2}$ is added, it is trivial to show that the Lipschitz constant increases by $\lambda K$, where $K$ is the upper bound for $\left\|\textbf{w}\right\|$. More generally, if a Tikhonov regularization term, $\left\|\boldsymbol{\Gamma}\textbf{w}\right\|_{2}^{2}$ term is added, then the increase in the Lipschitz constant can be computed as below.

[TABLE]

If $\textbf{w}_{1},\textbf{w}_{2}$ are bounded by $K$,

[TABLE]

This additional term may be added to the Lipschitz constants derived above when gradient descent is performed on a loss function including a Tikhonov regularization term. Clearly, for an $L_{2}$-regularizer, since $\boldsymbol{\Gamma}=\frac{\lambda}{2}\textbf{I}$, we have $L=\lambda K$.

6.4 A Note on Sigmoid activation and cross-entropy loss

Suppose that $y*$ is a latent, continuous random variable. In the case of logistic regression, (leading to binary cross entropy), we assume that $y*~{}f(x)+e$ where $e\sim$ logit(mean = 0) pdf. We can see that sigmoid is the CDF of logit distribution (or conversely, sigmoid is a valid CDF, and its derivate is the logit distribution), where $f(x)$ is the mean. Define $y=I(y*>0)$. Then,

[TABLE]

But $1-\sigma(-x)=\sigma(x)$ due to symmetry. Therefore,

[TABLE]

The negative log-likelihood under the above generative model results in the binary cross entropy.

7 Going Beyond SGD

The framework presented so far easily extends to algorithms that extend SGD, such as RMSprop, momentum, and Adam. In this section, we show algorithms for some major optimization algorithms popularly used.

RMSprop, gradient descent with momentum, and Adam are based on exponentially weighted averages of the gradients. The trick then is to compute the Lipschitz constant as an exponentially weighted average of the norms of the gradients. This makes sense, since it provides a supremum of the “velocity” or “accumulator” terms in momentum and RMSprop respectively.

7.1 Gradient Descent with Momentum

SGD with momentum uses an exponentially weighted average of the gradient as a velocity term. The gradient is replaced by the velocity in the weight update rule.

Algorithm 1 shows the adaptive version of gradient descent with momentum. The only changes are on lines 1 and 1. The exponentially weighted average of the Lipschitz constant ensures that the learning rate for that iteration is optimal. The weight update is changed to reflect our new learning rate. We use the symbol $W$ to consistently refer to the weights as well as the biases; while “parameters” may be a more apt term, we use $W$ to stay consistent with literature.

Notice that only line 1 is our job; deep learning frameworks will typically take care of the rest; we simply need to compute $K$ and use a learning rate scheduler that uses the inverse of this value.

7.2 RMSprop

RMSprop uses an exponentially weighted average of the square of the gradients. The square is performed element-wise, and thus preserves dimensions. The update rule in RMSprop replaces the gradient with the ratio of the current gradient and the exponentially moving average. A small value $\epsilon$ is added to the denominator for numerical stability.

Algorithm 2 shows the modified version of RMSprop. We simply maintain an exponentially weighted average of the Lipschitz constant as before; the learning rate is also replaced by the inverse of the update term, with the exponentially weighted average of the square of the gradient replaced with our computed exponentially weighted average.

7.3 Adam

Adam combines the above two algorithms. We thus need to maintain two exponentially weighted average terms. The algorithm, shown in Algorithm 3, is quite straightforward.

In our experiments, we use the defaults of $\beta_{1}=0.9,\beta_{2}=0.999$.

In practice, it is difficult to get a good estimate of $\max\left\lVert(\nabla_{W}L)^{2}\right\rVert$. For this reason, we tried two different estimates:

• •

$\left\lVert(\max\nabla_{W}L)^{2}\right\rVert=\left\lVert\left(\frac{k-1}{km}K_{z}+\lambda\left\lVert w\right\rVert\right)^{2}\right\rVert$ – This set the learning rate high (around 4 on CIFAR-10 with DenseNet), and the model quickly diverged.

• •

$\left(\max\left\lVert\nabla_{W}L\right\rVert\right)^{2}=\frac{(k-1)^{2}}{k^{2}m^{2}}\max K_{z}^{2}+\lambda^{2}(\max\left\lVert w\right\rVert)^{2}+\frac{2\lambda(k-1)}{km}K_{z}(\max\left\lVert w\right\rVert)$ – This turned out to be an overestimation, and while the same model above did not diverge, it oscillated around a local minimum. We fixed this by removing the middle term. This worked quite well empirically.

7.4 A note on bias correction

Some implementations of the above algorithms perform bias correction as well. This involves computing the exponentially weighted average, and then dividing by $1-\beta^{t}$, where $t$ is the epoch number. In this case, the above algorithms may be adjusted by also dividing the Lipschitz constants by the same constant.

8 Experiments and Results

In this section, we show through extensive experimentation that our approach converges faster, and performs better than with a standard choice of learning rate.

8.1 Faster convergence

For checking the rate of convergence, we use classical machine learning models. In each experiment, we randomly initialize weights, and use the same initial weight vector for gradient descent with both the learning rates. In all experiments, we scale each feature to sum to 1 before running gradient descent. This scaled data is used to compute the Lipschitz constants, and consequently, the learning rates. Normalizing the data is particularly important because the Lipschitz constant may get arbitrarily large, thus making the learning rate too small.

The regression experiments use a multiple linear regression model, the binary classification experiments use an ordinary logistic regression model, and the multi-class classification experiments use a softmax regression model with one-hot encoded target labels. For MNIST, however, we found it quicker to train a neural network with only an input and output layer (no hidden layers were used), a stochastic gradient descent optimizer, and softmax activations.

We compare the rate of convergence by setting a threshold, $T_{L}$ for the value of the loss function. When the value of the cost function goes below this threshold, we stop the gradient descent procedure. A reasonable threshold value is chosen for each dataset separately. We then compare $E_{0.1}$ and $E_{1/L}$, where $E_{\alpha}$ represents the number of epochs taken for the loss to go below $T_{L}$. For the Cover Type data, we considered only the first two out of seven classes. This resulted in 495,141 rows. We also considered only ten features to speed up computation time.

For the least-squares cost function, an estimate of $K$ is required. A good estimate of $K$ would be obtained by running gradient descent with some fixed learning rate and then taking the norm of the final weight vectors. However, because this requires actually running the algorithm for which we want to find a parameter first, we need to estimate this value instead. In our experiments, we obtain a close approximation to the value obtained above through the formula below. For the experiments in this subsection, we use this formula to compute $K$.

[TABLE]

In the above formulas, the notation $x^{(i)}_{j}$ refers to the $j$th column of the $i$th training example. Note that $a$ is the sum of the means of each column, and $b$ is the mean of the maximum of each column.

Table 1 shows the results of our experiments on some datasets. Clearly, our choice of $\alpha$ outperforms a random guess in all the datasets. Our proposed method yields a learning rate that adapts to each dataset to converge significantly faster than with a guess. In some datasets, our choice of learning rate gives over a 100x improvement in training time.

While the high learning rates may raise concerns of oscillations rather than convergence, we have checked for this in our experiments. To do this, we continued running gradient descent, monitoring the value of the loss function every 500 iterations. Figure 1 shows this plot, demonstrating that the high learning rates indeed lead to convergence.

8.2 Better performance

We tested the performance of our approach with both classical machine learning models and deep neural networks. In this section, we discuss the results of the former. To compare, we ran the models with different learning rates for a fixed number of epochs, $N_{E}$, and compared the accuracy scores $A_{0.1}$ and $A_{1/L}$, where $A_{\alpha}$ is the accuracy score after $N_{E}$ epochs with the learning rates 0.1 and $1/L$ respectively.

Table 2 shows the results of these experiments. Figure 2 shows a comparative plot of the training and validation accuracy scores for both learning rates on the MNIST dataset. In both the plots, the red line is for $\alpha=0.1$, while the green line is for $\alpha=\frac{1}{L}$. Although our choice of learning rate starts off worse, it quickly ($<100$ iterations) outperforms a learning rate of 0.1. Further, the validation accuracy has a decreasing tendency for $\alpha=0.1$, while it is more stable for $\alpha=1/L$.

8.3 Better performance in deep neural networks

We compared the performance of our approach with deep neural networks on standard datasets as well. While our results are not state of the art, our focus was to empirically show that optimization algorithms can be run with higher learning rates than typically understood. On CIFAR, we only use flipping and translation augmentation schemes as in [16]. In all experiments the raw image values were divided by 255 after removing the means across each channel. We also provide baseline experiments performed with a fixed learning rate for a fair comparison, using the same data augmentation scheme.

A summary of our experiments is given in Table LABEL:tab:exp:summary. DenseNet refers to a DenseNet[18] architecture with $L=40$ and $k=12$.

8.3.1 MNIST

On MNIST, the architecture we used is shown in Table 4. All activations except the last layer are ReLU; the last layer uses softmax activations. The model has 730K parameters.

Our preprocessing involved random shifts (up to 10%), zoom (to 10%), and rotations (to $15^{\circ}$). We used a batch size of 256, and ran the model for 20 epochs. The experiment on MNIST used only an adaptive learning rate, where the Lipschitz constant, and therefore, the learning rate was recomputed every epoch. Note that this works even though the penultimate layer is a Dropout layer. No regularization was used during training. With these settings, we achieved a training accuracy of 98.57% and validation accuracy 99.5%.

Finally, Figure 3(a) shows the computed learning rate over epochs. Note that unlike the computed adaptive learning rates for CIFAR-10 (Figures 3(b) and 3(c)) and CIFAR-100 (Figures 3(h) and 3(i)), the learning rate for MNIST starts at a much higher value. While the learning rate here seems much more random, it must be noted that this was run for only 20 epochs, and hence any variation is exaggerated in comparison to the other models, run for 300 epochs.

The results of our Adam optimizer is also shown in Table LABEL:tab:exp:summary. The optimizer achieved its peak validation accuracy after only 8 epochs.

We also used a custom implementation of SGD with momentum (see Appendix 0.A for details), and computed an adaptive learning rate using our AdaMo algorithm. Surprisingly, this outperformed both our adaptive SGD and Auto-Adam algorithms. However, the algorithm consistently chose a large (around 32) learning rate for the first epoch before computing more reasonable learning rates–since this hindered performance, we modified our AdaMo algorithm so that on the first epoch, the algorithm sets $K$ to 0.1 and uses this value as the learning rate. We discuss this issue further in Section 8.3.2.

8.3.2 CIFAR-10

For the CIFAR-10 experiments, we used a ResNet20 v1[16]. A residual network is a deep neural network that is made of “residual blocks”. A residual block is a special case of a highway networks [38] that do not contain any gates in their skip connections. ResNet v2 also uses “bottleneck” blocks, which consist of a 1x1 layer for reducing dimension, a 3x3 layer, and a 1x1 layer for restoring dimension [17]. More details can be found in the original ResNet papers [16, 17].

We ran two sets of experiments on CIFAR-10 using SGD. First, we empirically computed $K_{z}$ by running one epoch and finding the activations of the penultimate layer. We ran our model for 300 epochs using the same fixed learning rate. We used a batch size of 128, and a weight decay of $10^{-3}$. Our computed values of $K_{z}$, $\max\left\lVert w\right\rVert$, and learning rate were 206.695, 43.257, and 0.668 respectively. It should be noted that while computing the Lipschitz constant, $m$ in the denominator must be set to the batch size, not the total number of training examples. In our case, we set it to 128.

Figure 4 shows the plots of accuracy score and loss over time. As noted in [35], a horizontal validation loss indicates little overfitting. We achieved a training accuracy of 97.61% and a validation accuracy of 87.02% with these settings.

Second, we used the same hyperparameters as above, but recomputed $K_{z}$, $\max\left\lVert w\right\rVert$, and the learning rate every epoch. We obtained a training accuracy of 99.47% and validation accuracy of 89.37%. Clearly, this method is superior to a fixed learning rate policy.

Figure 3(b) and 3(c) show the learning rate over time. The adaptive scheme automatically chooses a decreasing learning rate, as suggested by literature on the subject. On the first epoch, however, the model chooses a very small learning rate of $8\times 10^{-3}$, owing to the random initialization.

Observe that while it does follow the conventional wisdom of choosing a higher learning rate initially to explore the weight space faster and then slowing down as it approaches the global minimum, it ends up choosing a significantly larger learning rate than traditionally used. Clearly, there is no need to decay learning rate by a multiplicative factor. Our model with adaptive learning rate outperforms our model with a fixed learning rate in only 65 epochs. Further, the generalization error is lower with the adaptive learning rate scheme using the same weight decay value. This seems to confirm the notion in [36] that large learning rates have a regularization effect.

Figures 3(d) and 3(e) show the learning rate over time on CIFAR-10 using a DenseNet architecture and SGD. Evidently, the algorithm automatically adjusts the learning rate as needed.

Interestingly, in all our experiments, ResNets consistently performed poorly when run with our auto-Adam algorithm. Despite using fixed and adaptive learning rates, and several weight decay values, we could not optimize ResNets using auto-Adam. DenseNets and our custom architecture on MNIST, however, had no such issues. Our best results with auto-Adam on ResNet20 and CIFAR-10 were when we continued using the learning rate of the first epoch (around 0.05) for all 300 epochs.

Figure 3(f) shows a possible explanation. Note that over time, our auto-Adam algorithm causes the learning rate to slowly increase. We postulate that this may be the reason for ResNet’s poor performance using our auto-Adam algorithm. However, using SGD, we are able to achieve competitive results for all architectures. We discuss this issue further in Section 9.

ResNets did work well with our AdaMo algorithm, though, performing nearly as well as with SGD. As with MNIST, we had to set the initial learning rate to a fixed value with AdaMo. We find that a reasonable choice of this is between 0.1 and 1 (both inclusive). We find that for higher values of weight decay, lower values of $x$ perform better, but we do not perform a more thorough investigation in this paper. In our experiments, we choose $x$ by simply trying 0.1, 0.5, and 1.0, running the model for five epochs, and choosing the one that performs the best. In Table LABEL:tab:exp:summary, for the first experiment using ResNet20 and momentum, we used $x=0.1$; for the second, we used $x=1$.

AdaMo also worked well with DenseNets on CIFAR-10. We used $x=0.5$ for this model. This model crossed 90% validation accuracy before 100 epochs, maintaining a learning rate higher than 1, and was the best among all our models trained on CIFAR-10. This shows the strength of our algorithm. Figure 3(g) shows the learning rate over epochs for this model.

8.3.3 CIFAR-100

For the CIFAR-100 experiments, we used a ResNet164 v2 [17]. Our experiments on CIFAR-100 only used an adaptive learning rate scheme.

We largely used the same parameters as before. Data augmentation involved only flipping and translation. We ran our model for 300 epochs, with a batch size of 128. As in [17], we used a weight decay of $10^{-4}$. We achieved a training accuracy of 99.68% and validation accuracy of 75.99% with these settings.

For the ResNet164 model trained using AdaMo, we found $x=0.5$ to be the best among the three that we tried. Note that it performs competitively compared to SGD. For DenseNet, we used $x=1$.

Figures 3(h) and 3(i) show the learning rate over epochs. As with CIFAR-10, the first two epochs start off with a very small ($10^{-8}$) learning rate, but the model quickly adjusts to changing weights.

8.3.4 Baseline Experiments

For our baseline experiments, we used the same weight decay value as our other experiments; the only difference was that we simply used a fixed value of the default learning rate for that experiment. For SGD and SGD with momentum, this meant a learning rate of 0.01. For Adam and RMSprop, the learning rate was 0.001. In SGD with momentum and RMSprop, $\beta=0.9$ was used. For Adam, $\beta_{1}=0.9$ and $\beta_{2}=0.999$ were used.

8.4 Comparison with other methods

In this section, we compare our results against other methods proposed in recent years. Because many papers do not test on CIFAR-100, we show comparisons on MNIST and CIFAR-10. We show the number of epochs and the validation accuracy. In cases where the paper reports only the validation loss but not accuracy, we do not make a comparison. We also show our best performing result for comparison in each table.

For a fair comparison, we compare against the closest architecture used. Below, we compare against several recent adaptive learning rate methods.

AdaShift [48]: The authors show their results on MNIST and CIFAR-10 using a ResNet and a DenseNet. We compare our results accordingly in Tables 5-7.

AdaDelta [46]: The authors show their results on MNIST, and we provide a comparison in Table 8.

WN-Grad [44]: The authors show their results on MNIST and CIFAR-10, but for MNIST, they do not show validation accuracy scores, only the loss values. However, it is incorrect to compare learners using their loss function values, as different points on the loss surface can have the same value but leading to different accuracy scores. Therefore, we only show a comparison on CIFAR-10 in Table 9.

AMSGrad [28]: The authors of AMSGrad only report loss values on MNIST and CIFAR-10, so we find that we cannot directly compare against their results. Fortunately, the authors of AdaShift [48] also report AMSGrad validation accuracy scores, so we compare our results against those values in Tables 10 - 12.

9 Practical Considerations

Although our approach is theoretically sound, there are a few practical issues that need to be considered. In this section, we discuss these issues, and possible remedies.

The first issue is that our approach takes longer per epoch than with choosing a standard learning rate. Our code was based on the Keras deep learning library, which to the best of our knowledge, does not include a mechanism to get outputs of intermediate layers directly. Other libraries like PyTorch, however, do provide this functionality through “hooks”. This eliminates the need to perform a partial forward propagation simply to obtain the penultimate layer activations, and saves computation time. We find that computing $\max\left\lVert w\right\rVert$ takes very little time, so it is not important to optimize its computation.

Another issue that causes practical issues is random initialization. Due to the random initialization of weights, it is difficult to compute the correct learning rate for the first epoch, because there is no data from a previous epoch to use. We discussed the effects of this already with respect to our AdaMo algorithm, and we believe this is the reason for the poor performance of auto-Adam in all our experiments. Fortunately, if this is the case, it can be spotted within the first two epochs–if large values of the intermediate computations: $\max\left\lVert w\right\rVert$, $K_{z}$, etc. are observed, then it may be required to set the initial LR to a suitable value. We discussed this for the AdaMo algorithm. In practice, we find that for RMSprop, this rarely occurs; but when it does, the large intermediate values are shown in the very first epoch. We find that a small value like $10^{-3}$ works well as the initial LR. In our experiments, we only had to do this for ResNet on CIFAR-100.

10 Discussion and Conclusion

In this paper, we derived a theoretical framework for computing an adaptive learning rate; on deriving the formulas for various common loss functions, it was revealed that this is also “adaptive” with respect to the data. We explored the effectiveness of this approach on several public datasets, with commonly used architectures and various types of layers.

Clearly, our approach works “out of the box” with various regularization methods including $L_{2}$, dropout, and batch normalization; thus, it does not interfere with regularization methods, and automatically chooses an optimal learning rate in stochastic gradient descent. On the contrary, we contend that our computed larger learning rates do indeed, as pointed out in [36], have a regularizing effect; for this reason, our experiments used small values of weight decay. Indeed, increasing the weight decay significantly hampered performance. This shows that “large” learning rates may not be harmful as once thought; rather, a large value may be used if carefully computed, along with a guarded value of $L_{2}$ weight decay. We also demonstrated the efficacy of our approach with other optimization algorithms, namely, SGD with momentum, RMSprop, and Adam. In summary, we have shown, beyond reasonable doubt, that sufficiently deep architectures may not be a necessity to accomplish state-of-the-art performance.

Our auto-Adam algorithm performs surprisingly poorly. We postulate that like AdaMo, our auto-Adam algorithm will perform better when initialized more thoughtfully. To test this hypothesis, we re-ran the experiment with ResNet20 on CIFAR-10, using the same weight decay. We fixed the value of $K_{1}$ to 1, and found the best value of $K_{2}$ in the same manner as for AdaMo, but this time, checking $10^{-3}$, $10^{-4}$, $10^{-5}$, and $10^{-6}$. We found that the lower this value, the better our results, and we chose $K_{2}=10^{-6}$. While at this stage we can only conjecture that this combination of $K_{1}$ and $K_{2}$ will work in all cases, we leave a more thorough investigation as future work. Using this configuration, we achieved 83.64% validation accuracy.

A second avenue of future work involves obtaining a tighter bound on the Lipschitz constant and thus computing a more accurate learning rate. Another possible direction is to investigate possible relationships between the weight decay and the initial learning rate in the AdaMo algorithm.

Conflicts of Interest

Funding: This work was supported by the Science and Engineering Research Board (SERB)-Department of Science and Technology (DST), Government of India (project reference number SERB-EMR/ 2016/005687). The funding source was not involved in the study design, writing of the report, or in the decision to submit this article for publication.

The authors declare that they have no other conflicts of interest.

Appendix 0.A Implementation Details

All our code was written using the Keras deep learning library. The architecture we used for MNIST was taken from a Kaggle Python notebook by Aditya Soni666https://www.kaggle.com/adityaecdrid/mnist-with-keras-for-beginners-99457. For ResNets, we used the code from the Examples section of the Keras documentation777https://keras.io/examples/cifar10_resnet/. The DenseNet implementation we used was from a GitHub repository by Somshubra Majumdar888https://github.com/titu1994/DenseNet. Finally, our implementation of SGD with momentum is a modified version of the Adam implementation in Keras999https://github.com/keras-team/keras/blob/master/keras/optimizers.py#L436.