Principled Approximation Methods for Efficient and Scalable Deep Learning

TL;DR

This paper introduces principled approximation techniques for deep learning that enhance efficiency and scalability through novel model compression, architecture search, and adaptive optimization, enabling high performance with reduced computational costs.

Contribution

It presents new approximation methods for pruning, quantization, neural architecture search, and adaptive optimization, addressing non-differentiability and discrete constraints in deep learning.

Findings

Significant efficiency improvements in training and inference.

Models maintain or improve performance after compression.

Effective exploration of recurrent architectures via parameter sharing.

Abstract

Recent progress in deep learning has been driven by increasingly larger models. However, their computational and energy demands have grown proportionally, creating significant barriers to their deployment and to a wider adoption of deep learning technologies. This thesis investigates principled approximation methods for improving the efficiency of deep learning systems, with a particular focus on settings that involve discrete constraints and non-differentiability. We study three main approaches toward improved efficiency: architecture design, model compression, and optimization. For model compression, we propose novel approximations for pruning and quantization that frame the underlying discrete problem as continuous and differentiable, enabling gradient-based training of compression schemes alongside the model's parameters. These approximations allow for fine-grained sparsity and precision configurations, leading to highly compact models without significant fine-tuning. In the context of architecture design, we design an algorithm for neural architecture search that leverages parameter sharing across layers to efficiently explore implicitly recurrent architectures. Finally, we study adaptive optimization, revisiting theoretical properties of widely used methods and proposing an adaptive optimizer that allows for quick hyperparameter tuning. Our contributions center on tackling computationally hard problems via scalable and principled approximations. Experimental results on image classification, language modeling, and generative modeling tasks show that the proposed methods provide significant improvements in terms of training and inference efficiency while maintaining, or even improving, the model's performance.

Figures

Tables

Table 1. Table 1 : Performance and parameter count of different models on CIFAR-10. * indicates models trained with dropout p = 0.3 p=0.3 (Srivastava et al., 2014 ) . Best WRN/SWRN result is in bold, and best overall performance is underlined. Results are average of 5 runs.

CIFAR-10	Templates /	Dropout	Params (M)	Compression	Test
Architecture	Group size			Ratio ($\times$)	Error ($\%$)
WRN 28-10		0.0	36		4.00
WRN 28-10		0.3	36		3.89
ResNeXt-29 16x64		0.0	68		3.58
DenseNet 100-24		0.0	27		3.74
DenseNet 190-40		0.3	26		3.46
SWRN 28-10-1	1 / 6	0.0	12	3.0	4.01
SWRN 28-10-2	2 / 6	0.3	17	2.1	3.75
SWRN 28-10	6 / 6	0.0	36	1.0	3.74
SWRN 28-10	6 / 6	0.3	36	1.0	3.88
SWRN 28-14-2	2 / 6	0.3	33	2.1	3.69
SWRN 28-14	6 / 6	0.3	71	1.0	3.67
SWRN 28-18-2	2 / 6	0.3	55	2.1	3.43
SWRN 28-18	6 / 6	0.3	118	1.0	3.48

Table 2. Table 2 : Performance and parameter count of different models on CIFAR-100. * indicates models trained with dropout p = 0.3 p=0.3 (Srivastava et al., 2014 ) . Best WRN/SWRN result is in bold, and best overall performance is underlined. Results are average of 5 runs.

CIFAR-100	Templates /	Dropout	Params (M)	Compression	Test
Architecture	Group size			Ratio ($\times$)	Error ($\%$)
WRN 28-10		0.0	36		19.25
WRN 28-10		0.3	36		18.85
ResNeXt-29 16x64		0.0	68		17.31
DenseNet 100-24		0.0	27		19.25
DenseNet 190-40		0.3	26		17.18
SWRN 28-10-1	1 / 6	0.0	12	3.0	19.73
SWRN 28-10-2	2 / 6	0.3	17	2.1	18.66
SWRN 28-10	6 / 6	0.0	36	1.0	18.78
SWRN 28-10	6 / 6	0.3	36	1.0	18.43
SWRN 28-14-2	2 / 6	0.3	33	2.1	18.37
SWRN 28-14	6 / 6	0.3	71	1.0	18.25
SWRN 28-18-2	2 / 6	0.3	55	2.1	17.75
SWRN 28-18	6 / 6	0.3	118	1.0	17.43

Table 3. Table 3 : Performance of models found via neural architecture search (NAS) on CIFAR-10 (all trained with cutout).

CIFAR-10	Params (M)	Training Time (GPU days)	Test error (%)
NASNet-A	3.3	1800	2.65
NASNet-A	27.6	1800	2.40
AmoebaNet-B	2.8	3150	2.55
AmoebaNet-B	13.7	3150	2.31
AmoebaNet-B	26.7	3150	2.21
AmoebaNet-B	34.9	3150	2.13
DARTS	3.4	4	2.83
SNAS	2.8	1.5	2.85
ENAS	4.6	0.45	2.89
WRN 28-10	36.4	0.4	3.08
(baseline with cutout)
SWRN 28-4-2	2.7	0.12	3.45
SWRN 28-6-2	6.1	0.25	3.00
SWRN 28-10	36.4	0.4	2.70
SWRN 28-10-2	17.1	0.4	2.69
SWRN 28-14	71.4	0.7	2.55
SWRN 28-14-2	33.5	0.7	2.53

Table 4. Table 4 : Performance of different models on ImageNet.

ImageNet	Params (M)	Top-1 error ($\%$)	Top-5 error ($\%$)
WRN 50-2	69	22.00	6.05
DenseNet-264	33	22.15	6.12
ResNet-200	65	21.66	5.79
SWRN 50-2	69	21.74	5.95

Table 5. Table 5 : Sparsity (%) of the sparsest subnetwork within 2 % 2\% test accuracy of the original dense model, for different pruning methods on CIFAR.

	Louizos et al. (2018)	AMC	MP	GMP	NetSlim	CS
VGG-16	18.2%	86.0%	97.5%	98.0%	99.0%	99.6%
ResNet-20	13.6%	50.0%	80.0%	86.0%	85.0%	94.4%

Table 6. Table 6 : Test accuracy and sparsity of the sparsest matching and best performing subnetworks produced by CS, IMP, and IMP-C (IMP without rewinding) for VGG-16 and ResNet-20 trained on CIFAR-10.

			VGG-16				ResNet-20
Method			Round	Test	Weights		Round	Test	Weights
				Accuracy	Remaining			Accuracy	Remaining
Dense Network			1	92.35%	100.0%		1	90.55%	100.0%
Sparsest	IMP		18	92.36%	1.8%		7	90.57%	20.9%
Matching	IMP-C		18	92.56%	1.8%		8	91.00%	16.7%
Subnetwork	CS		5	93.35%	1.7%		5	91.43%	12.3%
Best	IMP		13	92.97%	5.5%		6	90.67%	26.2%
Performing	IMP-C		12	92.77%	6.9%		4	91.08%	40.9%
Subnetwork	CS		4	93.45%	2.4%		5	91.54%	16.9%

Table 7. Table 8 : Performance of different quantization methods on ResNet-20 when trained on CIFAR-10. * denotes results with Zero Precision Allocation.

		ResNet-20
Method	Precision	Avg. Bpp $\downarrow$	Test
	Granularity	(Ratio $\uparrow$)	Acc. $(\%)$
LQ-FP		32.0 (1.0)	92.1
BSQ-FP		32.0 (1.0)	92.6
LQ-Nets	Network	1.0 (32.0)	90.1
DSQ	Network	1.0 (32.0)	90.2
SLB	Network	1.0 (32.0)	90.6
LQ-Nets	Network	2.0 (16.0)	91.8
SLB	Network	2.0 (16.0)	92.0
SMOL*	Parameter	1.3 (24.6)	91.5
SMOL*	Parameter	1.7 (18.8)	92.6
LQ-Nets	Network	3.0 (10.7)	92.0
BSQ	Layer	2.7 (11.9)	91.9
SMOL-L	Layer	2.4 (13.3)	92.4
SMOL	Parameter	2.1 (15.2)	92.5
SMOL	Parameter	2.5 (12.8)	92.8
BSQ	Layer	3.2 (10.0)	92.8
SMOL-L	Layer	3.2 (10.0)	93.0
SMOL	Parameter	2.8 (11.4)	93.0

Table 8. Table 9 : Performance of SMOL and BSQ on MobileNetV2 and ShuffleNet when trained on CIFAR-10.

	MobileNetV2			ShuffleNet
Method	Avg.	Test		Avg.	Test
	Bpp $\downarrow$	Acc.		Bpp $\downarrow$	Acc.
FP	32.0	94.4		32.0	90.7
BSQ	2.8	94.1		3.4	91.8
SMOL	1.5	94.5		1.8	91.6
SMOL	1.7	94.8		2.9	92.0

Table 9. Table 10 : Performance of different quantization methods on ResNet-18 and ResNet-50 models trained on ImageNet. * denotes results with Zero Precision Allocation.

		ResNet-18				ResNet-50
Method		Average	Compression	Test		Average	Compression	Test
		Bpp $\downarrow$	Ratio $\uparrow$	Accuracy $(\%)$		Bpp $\downarrow$	Ratio $\uparrow$	Accuracy $(\%)$
FP		32.0	1.0	69.6		32.0	1.0	76.1
SLB		2.0/4	16.0	67.5
LQ-Nets		3.0/3	10.7	68.2		3.0/3	10.7	74.2
SMOL*						0.8/4	40.0	74.6
SMOL*		2.3/4	13.9	69.9		2.2/4	14.5	74.9
LQ-Nets		4.0/4	8.0	69.3		4.0/4	8.0	75.1
DSQ		4.0/4	8.0	69.6
BSQ						3.3/4	9.7	75.2
BSQ						3.7/4	8.6	75.3
SMOL*						4.1/4	7.0	77.1
SMOL		4.5/4	7.1	70.6
SMOL		4.2/4	7.6	70.4		5.3/4	5.9	76.9

Table 10. Table 11 : Performance of BSQ and SMOL on image generation on CIFAR-10 with DCGANs.

	DCGAN
Method	Avg.	Inception	FID $\downarrow$
	Bpp $\downarrow$	Score $\uparrow$
FP (30 epochs)	32.0	4.70	38.6
FP (160 epochs)	32.0	5.67	25.8
BSQ	2.8	4.85	38.3
SMOL*	0.2	4.75	35.6
SMOL*	0.5	5.03	34.1
SMOL*	1.0	5.01	31.1
SMOL	1.7	5.02	34.1
BSQ	3.9	4.95	37.1
SMOLs*	3.5	5.29	29.9

Table 11. Table 12 : Performance of PACT and SMOL when quantizing activations of a ResNet-20 trained on CIFAR-10.

	ResNet-20
Method	Avg.	Test
	Bpa $\downarrow$	Acc. $(\%)$
FP	32.0	91.6
PACT	2.0	89.2
SMOL-A	1.8	90.3
PACT	3.0	91.4
SMOL-A	2.9	91.8
SMOL-A	2.5	91.4
PACT	5.0	91.6

Table 12. Table 13 : Comparison between a ResNet-20 trained on CIFAR-10 with SMOL and its performance when re-trained, either when the per-weight precision assignments are maintained or randomly permuted (shuffled).

			ResNet-20
Method			Average	Compression	Test
			Bpp $\downarrow$	Ratio $(\times )$ $\uparrow$	Accuracy $(\%)$
Original (SMOL)			2.5	12.8	92.8
Re-trained with same precisions			2.5	12.8	91.5
Re-trained with shuffled precisions			2.5	12.8	89.3

Table 13. Table 14 : Performance of SMOL when quantizing a Transformer on IWSLT’14.

	Transformer
Method	Avg.	BLEU
	Bpp $\downarrow$	Score $\uparrow$
FP	32.0	34.9
SMOL	3.9	34.7
SMOL	5.8	34.9

Table 14. Table 15 : Test performance of standard models on benchmark tasks, when trained with different optimizers. Gray background indicates the optimization method (baseline) adopted by the paper that proposed the corresponding network model. The best task-wise results are in bold, while other improvements over the baselines are underlined. Numbers in parentheses indicate standard deviation over three runs. Across tasks, AvaGrad closely matches or exceeds the results delivered by existing optimizers, and offers notable improvement in FID when training GANs.

	CIFAR-10 Test Err%	CIFAR-100 Test Err %	ImageNet Val Err %	CIFAR-10 FID $\downarrow$
Model	WRN 28-10	WRN 28-10	ResNet-50	GGAN
SGD	3.86 (0.08)	19.05 (0.24)	24.01	133.0
Adam	3.64 (0.06)	18.96 (0.21)	23.45	43.0
AMSGrad	3.90 (0.17)	18.97 (0.09)	23.46	41.3
AdaBound	5.40 (0.24)	22.76 (0.17)	27.99	247.3
AdaShift	4.08 (0.11)	18.88 (0.06)	OOM	43.7
RAdam	3.89 (0.09)	19.15 (0.13)	23.60	42.5
AdaBelief	3.98 (0.07)	19.08 (0.09)	24.11	44.8
AdamW	4.11 (0.17)	20.13 (0.22)	26.70	—
AvaGrad	3.80 (0.02)	18.76 (0.20)	23.58	35.3
AvaGradW	3.97 (0.02)	19.04 (0.37)	23.49	—

Table 15. Table 16 : Test performance of standard models on benchmark tasks, when trained with different optimizers. Gray background indicates the optimization method (baseline) adopted by the paper that proposed the corresponding network model. The best task-wise results are in bold, while other improvements over the baselines are underlined. Numbers in parentheses indicate standard deviation over three runs. Across tasks, AvaGrad closely matches or exceeds the results delivered by existing optimizers, and offers notable improvement in FID when training GANs.

	Penn Treebank Test BPC $\downarrow$	Penn Treebank Test BPC $\downarrow$
Model	3xLSTM(300)	3xLSTM(1000)
SGD	1.403 (0.000)	1.237 (0.000)
Adam	1.378 (0.001)	1.182 (0.000)
AMSGrad	1.384 (0.001)	1.187 (0.001)
AdaBound	4.346 (0.000)	2.891 (0.041)
AdaShift	1.399 (0.006)	1.199 (0.001)
RAdam	1.401 (0.002)	1.349 (0.003)
AdaBelief	1.379 (0.001)	1.198 (0.000)
AdamW	1.398 (0.002)	1.227 (0.003)
AvaGrad	1.375 (0.000)	1.179 (0.000)
AvaGradW	1.375 (0.001)	1.175 (0.000)

Equations

$$h^{(l)}=f_l(h^{(1)},\dots ,h^{(l-1)},\theta ),$$

$$\text{mathbbm}1\{P\}:=\{\begin{array}{l}1,\text{if P is true}\\ 0,\text{otherwise}.\end{array}$$

$$\underset{f\in \mathcal{F}}{\min }\underset{{\theta }_f\in {\Theta }_f}{\min }\mathcal{L}(f({\theta }_f)).$$

$$\mathcal{F}_{F}=\left\{{(W^{(l)})}_{l=1}^{L}\mapsto h^{(\alpha_{L})}(W^{(L)})\circ\dots\circ h^{(\alpha_{1})}(W^{(1)})~\Big{|}~\alpha\in[k]^{L}\right\}\,,$$

$$\mathcal{H}=\Big{\{}W\mapsto\text{Conv}_{3\times 3}(W),W\mapsto\text{Conv}_{5\times 5}(W),W\mapsto\text{Id}\Big{\}}\,,$$

$${\mathcal{F}}_T=\left\{{(W^{(l)})}_{l=1}^k\mapsto h^{(L)}(W^{({\alpha }_L)})\circ \cdots \circ h^{(1)}(W^{({\alpha }_1)})|\alpha \in [k{]}^L\right\},$$

$$\underset{\alpha \in [k{]}^L}{\min }\underset{\theta \in \Theta }{\min }\mathcal{L}(\mathcal{F}(\alpha )(\theta )),$$

$$\overline{\mathcal{F}}_{T}=\left\{{(T^{(i)})}_{i=1}^{k}\mapsto h^{(L)}\left(\sum_{i=1}^{k}\alpha^{(L)}_{i}T^{(i)}\right)\circ\dots\circ h^{(1)}\left(\sum_{i=1}^{k}\alpha^{(1)}_{i}T^{(i)}\right)~\Big{|}~\alpha\in(\mathbb{R}^{k})^{L}\right\}\,,$$

$${\mathbb{B}}^k=(e^{(j)}{)}_{j=1}^k\subset {\mathbb{R}}^k,$$

$$\left\{\overline{\mathcal{F}}_{T}(\alpha)~\big{|}~\alpha\in(\mathbb{B}^{k})^{L}\subset(\mathbb{R}^{k})^{L}\right\}=\mathcal{F}_{T}\,,$$

$$\underset{\begin{array}{c}\alpha \in ({\mathbb{B}}^k{)}^L\\ \theta \in \Theta \end{array}}{\min }\mathcal{L}({\overline{\mathcal{F}}}_T(\alpha )(\theta )).$$

$$\underset{\begin{array}{c}\alpha \in ({\mathbb{R}}^k{)}^L\\ \theta \in \Theta \end{array}}{\min }\mathcal{L}({\overline{\mathcal{F}}}_T(\alpha )(\theta )).$$

$$W^{(l)}=\sum _{i=1}^k{\alpha }_i^{(l)}{T}^{(i)}.$$

$$\begin{array}{rl}{u}^{(l)}(u^{(l-1)})=W^{(l)}{u}^{(l-1)}=\left(\sum _{i=1}^k{\alpha }_i^{(l)}{T}^{(i)}\right)u^{(l-1)}& =\sum _{i=1}^k{\alpha }_i^{(l)}\left(T^{(i)}{u}^{(l-1)}\right)\\ & =\sum _{i=1}^k{\alpha }_i^{(l)}{\tilde{u}}^{(i)}(u^{(l-1)}),\end{array}$$

$$S_{l,l^{\prime }}=\frac{|⟨{\alpha }^{(l)},{\alpha }^{(l^{\prime })}⟩|}{\Vert {\alpha }^{(l)}\Vert \Vert {\alpha }^{(l^{\prime })}\Vert }.$$

$$\begin{array}{rl}{T}^{\prime }& =BT\\ {\alpha }^{\prime }& =(B^T{)}^{-1}\alpha ,\end{array}$$

$$\alpha =\left[\begin{array}{ccccc}0.8& 0.1& -1.2& 0.2& -0.4\\ -0.2& 0.6& 0.3& 1.2& -0.3\\ 0.6& -0.2& -0.9& -0.4& 0.7\\ 0.2& 1.2& -0.3& 2.4& -0.1\end{array}\right],$$

$$LSM=\left[\begin{array}{ccccc}1& 0.05& 1& 0.05& 0.15\\ 0.05& 1& 0.05& 1& 0.40\\ 1& 0.05& 1& 0.05& 0.15\\ 0.05& 1& 0.05& 1& 0.40\\ 0.15& 0.40& 0.15& 0.40& 1\end{array}\right].$$

$${\alpha }^{\prime }=\left[\begin{array}{ccccc}1& 0& 1& 0& 0\\ 0& 1& 0& 1& 0\\ 0& 0& 0& 0& 1\end{array}\right].$$

$$B=(\alpha {{\alpha }^{\prime }}^T({\alpha }^{\prime }{{\alpha }^{\prime }}^T{)}^{-1}{)}^T=\left[\begin{array}{cccc}-0.2& 0.05& -0.15& -0.05\\ 0.15& 0.9& -0.3& 1.8\\ -0.4& 0.3& 0.7& -0.1\end{array}\right],$$

$${\mathcal{L}}_R(\alpha ,\theta )=\mathcal{L}(\alpha ,\theta )-\lambda \sum _{l,l^{\prime }}{S}_{l,l^{\prime }}(\alpha ),$$

$$F_1(y,\hat{y})=\frac{{\sum }_i\text{mathbbm}1\{y_i={\hat{y}}_i=1\}}{{\sum }_i\text{mathbbm}1\{y_i=1\}+\text{mathbbm}1\{{\hat{y}}_i=1\}},$$

$$\underset{\begin{array}{c}\theta \in \Theta \end{array}}{\min }\mathcal{L}(f(\theta ))+\lambda \Vert \theta {\Vert }_0,$$

$$\Vert \theta {\Vert }_0=\sum _{i=1}^d\text{mathbbm}1\{{\theta }_i\ne 0\}$$

$$\Vert (W^{(l)}{)}_{l=1}^L{\Vert }_0=\sum _{l=1}^L\sum _{i=1}^{d_l}\text{mathbbm}1\{W_i^{(l)}\ne \vec{0}\},$$

$$(m\odot \theta {)}_i=m_i{\theta }_i=\{\begin{array}{l}{\theta }_i,\text{if }{m}_i=1\\ 0,\text{if }{m}_i=0,\end{array}$$

$$\underset{\begin{array}{c}m\in \{0,1{\}}^d\\ \theta \in \Theta \end{array}}{\min }\mathcal{L}(f(m\odot \theta ))+\lambda \Vert m{\Vert }_p^p,$$

$$\min_{\begin{subarray}{c}s\in\mathbb{R}^{d}\\ \theta\in\Theta\end{subarray}}\quad\mathcal{L}\big{(}f(b(s)\odot\theta)\big{)}+\lambda\|b(s)\|_{p}^{p}\,,$$

$$\underset{\beta \to \infty }{\lim }\hat{b}(\beta ,s)=b(s),$$

$$\underset{\beta \to \infty }{\lim }g(\hat{b}(\beta ,z))=g(b(z)).$$

Full text

We study three main approaches toward improved efficiency: architecture design, model compression, and optimization. For model compression, we propose novel approximations for pruning and quantization that frame the underlying discrete problem as continuous and differentiable, enabling gradient-based training of compression schemes alongside the model’s parameters. These approximations allow for fine-grained sparsity and precision configurations, leading to highly compact models without significant fine-tuning. In the context of architecture design, we design an algorithm for neural architecture search that leverages parameter sharing across layers to efficiently explore implicitly recurrent architectures. Finally, we study adaptive optimization, revisiting theoretical properties of widely used methods and proposing an adaptive optimizer that allows for quick hyperparameter tuning.

Our contributions center on tackling computationally hard problems via scalable and principled approximations. Experimental results on image classification, language modeling, and generative modeling tasks show that the proposed methods provide significant improvements in terms of training and inference efficiency while maintaining, or even improving, the model’s performance.

To my parents.

1. 1 Introduction

2. 1 Overview

3. 2 Thesis Goal

4. 3 Organization and Contributions

5. 2 Preliminaries

6. 4 Notation

7. 5 Background

8. 5.1 Efficiency

9. 5.2 Model Compression

10. 5.3 Parameter Optimization

11. 3 Neural Architecture Search via Parameter Sharing

12. 6 Introduction

13. 6.1 Motivation & Strategy

14. 6.2 Related Work

15. 7 Method

16. 7.1 Formalizing the Architecture Search Problem

17. 7.2 Re-framing the Architecture Search Problem

18. 7.3 Approximating the Architecture Search Problem

19. 7.4 The Proposed Architecture Search Method

20. 8 Experimental Setup

21. 8.1 Datasets

22. 8.2 Models

23. 8.3 Training

24. 8.4 Evaluation

25. 9 Results

26. 9.1 Improving Network Efficiency

27. 9.2 Architecture Search

28. 9.3 Algorithmic Task

29. 10 Experimental Analysis

30. 11 Discussion

31. 11.1 Contributions

32. 11.2 Research Directions

33. 11.3 Impact

34. 4 Sparsification

35. 12 Introduction

36. 12.1 Motivation & Strategy

37. 12.2 Related Work

38. 13 Method

39. 13.1 Formalizing the Sparsification Problem

40. 13.2 Re-framing the Sparsification Problem

41. 13.3 Approximating the Sparsification Problem

42. 13.4 The Proposed Sparsification Method

43. 14 Experimental Setup

44. 14.1 Datasets

45. 14.2 Models

46. 14.3 Training

47. 14.4 Evaluation

48. 15 Results

49. 15.1 Sparsification on CIFAR

50. 15.2 Finding Winning Tickets

51. 15.3 Residual Networks on ImageNet

52. 16 Experimental Analysis

53. 16.1 Hyperparameter Analysis

54. 16.2 Iterative Stochastic Sparsification

55. 16.3 Searching for Supermasks

56. 16.4 Additional Ticket Search Experiments

57. 16.5 Sequential Search with Continuous Sparsification

58. 17 Discussion

59. 17.1 Contributions

60. 17.2 Research Directions

61. 17.3 Impact

62. 5 Quantization

63. 18 Introduction

64. 18.1 Motivation & Strategy

65. 18.2 Related Work

66. 19 Method

67. 19.1 Formalizing the Quantization Problem

68. 19.2 Re-framing the Quantization Problem

69. 19.3 Approximating the Quantization Problem

70. 19.4 The Proposed Quantization Method

71. 20 Experimental Setup

72. 20.1 Datasets

73. 20.2 Models

74. 20.3 Training

75. 20.4 Evaluation

76. 21 Results

77. 21.1 Quantizing Weights

78. 21.2 Quantizing GANs

79. 21.3 Quantizing Activations

80. 21.4 Computational Efficiency

81. 22 Experimental Analysis

82. 22.1 Layer-wise Precision Pattern

83. 22.2 Balancing Precision Optimization and Fine-Tuning

84. 22.3 Underlying Structure in Precision Patterns

85. 22.4 Quantizing Transformers

86. 23 Discussion

87. 23.1 Contributions

88. 23.2 Research Directions

89. 23.3 Impact

90. 6 Leveraging Parameter Structure

91. 24 Introduction

92. 24.1 Motivation & Strategy

93. 24.2 Related Work

94. 25 Method

95. 25.1 Non-convex Optimization

96. 25.2 The Role of Adaptivity

97. 25.3 AvaGrad

98. 26 Experimental Setup

99. 26.1 Datasets

100. 26.2 Models

101. 26.3 Training

102. 26.4 Evaluation

103. 27 Results

104. 27.1 Improving Performance

105. 27.2 Hyperparameter Separability

106. 27.3 Hyperparameter Optimization

107. 28 Analysis

108. 28.1 Convergence

109. 29 Discussion

110. 29.1 Contributions

111. 29.2 Research Directions

112. 29.3 Impact

113. 30 Proofs

114. 31 Full Statement and Proof of Theorem 6.1

115. 32 Technical Lemmas

116. 33 Proof of Theorem 6.3

117. 33.1 Proof of the first guarantee (Equation 67)

118. 33.2 Proof of the second guarantee (Equation 68)

119. 34 Full Statement and Proof of Theorem 6.2

1. 1 Illustration of our soft parameter sharing scheme. Left: A two-layer feedforward CNN. Middle: Our parameter sharing scheme applied to the same two-layer CNN.. Right: Equivalent view of the middle diagram, where template layers are used and combined instead of template weights.
2. 2 LSM when training with and without parameter sharing, and its connection to the network’s topology. White and black entries correspond to maximum and minimum similarities. Left: LSM of networks trained without parameter sharing. Middle: LSM of networks trained with our soft parameter sharing mechanism. Right: Using the LSM, we can fold the network to produce a smaller model with backward connections.
3. 3 Parameter efficiency for different models on CIFAR-10.
4. 4 Parameter efficiency for different models on CIFAR-100.
5. 5 Folding a SWRN 28-10-4 trained on CIFAR-10. Left: Illustration of its stages. Middle: LSM for each stage after training. Right: Folding stages 2 and 3.
6. 6 1 Folding a SWRN 40-8-8 trained on CIFAR-10. Red paths are taken before green, which are taken before blue.
7. 7 Folding a SWRN 40-8-8 trained on CIFAR-10.
8. 8 Example of the synthetic shortest paths task.
9. 9 Training curves for the shortest paths task.
10. 10 LSMs of a SWRN 40-8-8 over different runs.
11. 11 LSMs of a SWRN 40-8-8 over different epochs of the same run.
12. 12 LSM evolution for 100-layer CNN trained on synthetic task (0, 20, 40 epochs).
13. 13 Performance of different methods when performing one-shot pruning on VGG-16, measured in terms of test accuracy and sparsity of produced subnetworks after fine-tuning.
14. 14 Performance of different methods when performing one-shot pruning on ResNet-20, measured in terms of test accuracy and sparsity of produced subnetworks after fine-tuning.
15. 15 VGG-16 on CIFAR-10. Test accuracy and sparsity of subnetworks produced by IMP and CS after re-training from weights of epoch 2. Purple curves show individual runs of CS, while the green curve connects tickets produced after 5 rounds of CS with varying $s^{(0)}$. Iterative Magnitude Pruning (continued) refers to IMP without rewinding between rounds. Error bars depict variance across 3 runs.
16. 16 ResNet-20 on CIFAR-10. Test accuracy and sparsity of subnetworks produced by IMP and CS after re-training from weights of epoch 2. Purple curves show individual runs of CS, while the green curve connects tickets produced after 5 rounds of CS with varying $s^{(0)}$. Iterative Magnitude Pruning (continued) refers to IMP without rewinding between rounds. Error bars depict variance across 3 runs.
17. 17 Impact on relative test accuracy and sparsity of tickets found by CS in a ResNet-20 trained on CIFAR-10, for different values of $\lambda$ and fixed settings for $\beta_{final}$ and $s_{init}$.
18. 18 Impact on relative test accuracy and sparsity of tickets found by CS in a ResNet-20 trained on CIFAR-10, for different values of $\beta_{final}$ and fixed settings for $\lambda$ and $s_{init}$.
19. 19 Impact on relative test accuracy and sparsity of tickets found by CS in a ResNet-20 trained on CIFAR-10, for different values of $s_{init}$ and fixed settings for $\beta_{final}$ and $\lambda$.
20. 20 Performance of tickets found by Iterative Magnitude Pruning in a ResNet-20 trained on CIFAR-10, for different pruning rates.
21. 21 Learning a binary mask with weights frozen at initialization with Stochastic Sparsification (SS, Algorithm 4 with one iteration) and Continuous Sparsification (CS), on a 6-layer CNN on CIFAR-10. Training curves with hyperparameters for which masks learned by SS and CS were both approximately $50\%$ sparse. CS learns the mask significantly faster while attaining similar early-stop performance.
22. 22 Learning a binary mask with weights frozen at initialization with Stochastic Sparsification (SS, Algorithm 4 with one iteration) and Continuous Sparsification (CS), on a 6-layer CNN on CIFAR-10. Sparsity and test accuracy of masks learned with different settings for SS and CS: our method learns sparser masks while maintaining test performance, while SS is unable to successfully learn masks with over $50\%$ sparsity.
23. 23 Accuracy and sparsity of tickets produced by IMP, ISS and CS after re-training, starting from initialization. Tickets are extracted from a Conv-6 network trained on CIFAR-10. Purple curves show individual runs of CS, while green curve connects tickets produced after 4 rounds of CS with varying $s_{init}$. Blue and red curves show performance and sparsity of tickets produced by IMP and ISS, respectively. Error bars depict variance across 3 runs.
24. 24 Sparsity patterns learned by CS and IMP for VGG-16 trained on CIFAR-10 – each block consists of 2 non-overlapping consecutive layers of VGG.
25. 25 Accuracy and sparsity of tickets produced by IMP and Sequential CS after re-training, starting from weights of epoch 2. Tickets are extracted from a ResNet-20 trained on CIFAR-10.
26. 26 Weight noise as a differentiable proxy for precision. A learnable magnitude $\delta$ scales uniform random noise added to weight $w$ during training. The width of the basin over which it is possible to perturb $w$ without increasing task loss $L$ drives learning of $\delta$. After training, we reduce the bit precision of the numeric representation of $w$ as much as possible, with the constraint of remaining in the $(w-\delta,w+\delta)$ range. Left: A random perturbation $\tilde{w}$ increases loss, driving a decrease in $\delta$. Middle: Perturbation leaves loss unchanged, driving an increase in $\delta$. Right: Noise level $\delta$, and the corresponding implied precision, stabilize when matched to the size of the basin.
27. 27 Multidimensional example where different precisions should be assigned to each parameter due to their distinct perturbation limits. Note the connection between each parameter’s perturbation limit, the width of the level curve in the parameter’s axis, and the allocated precision for each parameter.
28. 28 Performance of SMOL and BSQ when quantizing a ResNet-20 trained on CIFAR-10. SMOL-L denotes SMOL with layer-wise precisions.
29. 29 Performance of SMOL, BSQ, and LQ-Nets when quantizing a ResNet-50 trained on ImageNet. SMOL* denotes SMOL with zero-precision allocation.
30. 30 Image generations with a DCGAN trained on CIFAR-10, quantized with BSQ and SMOL.
31. 31 Layer-wise precisions allocated by SMOL-L on ResNet-20 models trained on CIFAR-10. The x-axis denotes the layer indices: leftmost points denote earlier layers while rightmost denote layers in the later stages of ResNet, which are closer to the final fully-connected layer.
32. 32 Performance and average precision of ResNet-20 trained on CIFAR-10 with SMOL when allocating different number of epochs to precision training versus fine-tuning. Curve shows increases of 50 epochs over a total of 650 epochs.
33. 33 Generalization performance when re-training networks, with and without randomly permuted (shuffled) precisions. The model whose precisions have been shuffled has visibly lower performance across all stages of training and achieves significantly lower final performance.
34. 34 Performance of Adam with different learning rate $\alpha$ and adaptability parameter $\epsilon$, measured in terms of validation error on CIFAR-10 of Wide ResNet 28-4. Best performance is achieved with low adaptability/large $\epsilon$.
35. 35 Performance of AvaGrad with different learning rate $\alpha$ and adaptability parameter $\epsilon$, measured in terms of validation error on CIFAR-10 of Wide ResNet 28-4. Best performance is achieved with low adaptability/large $\epsilon$.
36. 36 Performance of Adam with different learning rate $\alpha$ and adaptability parameter $\epsilon$, measured in terms of validation BPC (lower is better) on PTB of a 3-layer LSTM. Best performance is achieved with high adaptability/small $\epsilon$.
37. 37 Performance of AvaGrad with different learning rate $\alpha$ and adaptability parameter $\epsilon$, measured in terms of validation BPC (lower is better) on PTB of a 3-layer LSTM. Best performance is achieved with high adaptability/small $\epsilon$.
38. 38 Iterations to achieve $0.5\%$ suboptimality, measured in terms of validation accuracy on CIFAR-10, for Adam and AvaGrad when tuning $\alpha$ and $\epsilon$ with various standard hyperparameter optimizers.
39. 39 Suboptimality (gap in validation accuracy) when optimizing $\alpha$ and $\epsilon$ with GLD/CGLD, as a function of trials (i.e., validation accuracy evaluations for a value of $(\alpha,\epsilon)$): AvaGrad is significantly cheaper to tune than Adam, being especially efficient when adopting Coordinate GLD due to its hyperparameter separability.
40. 40 The mean gradient norm as function of the iteration $t$ when optimizing Equation (70). Matching our theoretical results, Delayed Adam and Adam with dynamic $\epsilon_{t}$ both converge, while Adam fails to converge.

1. 1 Performance and parameter count of different models on CIFAR-10. * indicates models trained with dropout $p=0.3$ (Srivastava et al., 2014). Best WRN/SWRN result is in bold, and best overall performance is underlined. Results are average of 5 runs.
2. 2 Performance and parameter count of different models on CIFAR-100. * indicates models trained with dropout $p=0.3$ (Srivastava et al., 2014). Best WRN/SWRN result is in bold, and best overall performance is underlined. Results are average of 5 runs.
3. 3 Performance of models found via neural architecture search (NAS) on CIFAR-10 (all trained with cutout).
4. 4 Performance of different models on ImageNet.
5. 5 Sparsity (%) of the sparsest subnetwork within $2\%$ test accuracy of the original dense model, for different pruning methods on CIFAR.
6. 6 Test accuracy and sparsity of the sparsest matching and best performing subnetworks produced by CS, IMP, and IMP-C (IMP without rewinding) for VGG-16 and ResNet-20 trained on CIFAR-10.
7. 7 Performance of sparsification on ResNet-50 trained on ImageNet. † denotes performance of ticket search.
8. 8 Performance of different quantization methods on ResNet-20 when trained on CIFAR-10. * denotes results with Zero Precision Allocation.
9. 9 Performance of SMOL and BSQ on MobileNetV2 and ShuffleNet when trained on CIFAR-10.
10. 10 Performance of different quantization methods on ResNet-18 and ResNet-50 models trained on ImageNet. * denotes results with Zero Precision Allocation.
11. 11 Performance of BSQ and SMOL on image generation on CIFAR-10 with DCGANs.
12. 12 Performance of PACT and SMOL when quantizing activations of a ResNet-20 trained on CIFAR-10.
13. 13 Comparison between a ResNet-20 trained on CIFAR-10 with SMOL and its performance when re-trained, either when the per-weight precision assignments are maintained or randomly permuted (shuffled).
14. 14 Performance of SMOL when quantizing a Transformer on IWSLT’14.
15. 15 Test performance of standard models on benchmark tasks, when trained with different optimizers. Gray background indicates the optimization method (baseline) adopted by the paper that proposed the corresponding network model. The best task-wise results are in bold, while other improvements over the baselines are underlined. Numbers in parentheses indicate standard deviation over three runs. Across tasks, AvaGrad closely matches or exceeds the results delivered by existing optimizers, and offers notable improvement in FID when training GANs.
16. 16 Test performance of standard models on benchmark tasks, when trained with different optimizers. Gray background indicates the optimization method (baseline) adopted by the paper that proposed the corresponding network model. The best task-wise results are in bold, while other improvements over the baselines are underlined. Numbers in parentheses indicate standard deviation over three runs. Across tasks, AvaGrad closely matches or exceeds the results delivered by existing optimizers, and offers notable improvement in FID when training GANs.

Chapter 1 Introduction

1 Overview

Deep neural networks have become widely adopted in fields such as computer vision (CV) and natural language processing (NLP) due to their unprecedented performance. In CV, increasing a network’s depth from tens to hundreds of layers led to major accuracy improvements in problems such as image classification and object detection, turning applications like autonomous driving and automated imaging diagnostics more reliable and closer to industry-level adoption. In NLP, the design of recurrent neural networks (RNNs) and transformers – models specialized for sequence-to-sequence problems – led to significant progress in language modeling and conversational agents, which are now being used to automate tasks such as customer service and content creation.

Nonetheless, deep learning faces significant obstacles in both theory and practice. Training deep networks is notoriously difficult due to the non-convex nature of the underlying optimization problem and remains poorly-understood in theory. While sophisticated optimization methods with desirable theoretical properties have been proposed and studied, empirical studies have shown that their theoretical qualities rarely translate into practice: first-order, gradient-based methods like SGD and Adam remain the backbone of neural network training.

Moreover, state-of-the-art models are becoming increasingly larger and more resource-intensive, posing additional challenges due to higher computational costs. Training such models typically requires numerous GPUs/TPUs, extensive time, and significant energy consumption, raising concerns about the technology’s applicability and accessibility. Addressing these challenges is fundamental to democratize the field and broaden its use in real-world applications. Possible solutions include advances in hardware design and production, use of more efficient network architectures, and faster training methods.

One approach to improve the efficiency of deep networks aims to reduce the size of overparameterized models in order to decrease their resource requirements when deployed. Recently, compression techniques such as pruning and quantization have proved successful in producing competitive models that can be deployed on edge devices, allowing for a broader range of applications to benefit from advances in the field.

Most model compression techniques e.g., pruning and quantization, introduce a discrete optimization sub-problem into the network’s training pipeline. These emerge from the need to make binary decisions, such as whether to remove a parameter, that can significantly impact the model’s performance and efficiency. Addressing such discrete sub-problems correctly can substantially reduce a model’s size and computational requirements while preserving, or even even enhancing, its performance on the underlying task. However, optimization problems of discrete nature are generally hard to solve optimally and cannot be tackled with gradient-based methods: discrete decisions, such as whether to prune or quantize a parameter, are not only non-differentiable but discontinuous.

Moreover, since the number of possible configurations increases exponentially with the dimensionality of the discrete variables, the computational complexity of the optimization problem generally follows the same intractable rate. This is particularly prohibitive in fine-grained compression of large models: for example, the complexity of parameter-wise pruning is exponential in the total number of parameters, which can be in the order of billions for large overparameterized models.

Among other challenges that arise when introducing discrete variables to a neural network’s training, one that is particularly aggravating arises from the dynamic nature of the optimization problem. More specifically, the optimal configuration for the discrete variables depends on the model’s weights, which are constantly changing during training. This poses a major obstacle to using model compression techniques to reduce training costs: compressing a partially-trained network yields configurations that are typically suboptimal for the weights’ final values, hence the configuration of the discrete variables needs to be revisited after further training.

Designing efficient methods to approximately solve discrete optimization problems has been an active research topic across various fields, resulting in an extensive literature of methods that have been analyzed and evaluated thoroughly. Many classical approaches, like greedy and linear approximations, are general and flexible enough that they can be readily applied to network compression. However, these general methods have been largely surpassed by newer ones tailored specifically for deep learning, which can frequently achieve high compression ratios while preserving the model’s performance.

Although state-of-the-art neural network compression methods are often still costly, they can be unreasonably effective at producing small models via aggressive pruning and quantization, in some cases removing up to 99% of a trained network’s weights while preserving its accuracy. Coupled with SGD’s inability to train small models from scratch, these observations raise key questions about the role of overparameterization in deep learning. Is the main role of overparameterization facilitating training with SGD? Are there optimization methods that do not require such aid and can successfully train small networks from scratch?

2 Thesis Goal

This thesis aims to explore methods to improve neural network training and inference efficiency through model compression and novel network training approaches. In particular, we study and design methods that have access to the network’s structure i.e., its computational graph, differing from most approaches in the literature. For model compression, we discuss sparsification/pruning, quantization, and parameter re-use, focusing on designing approximations that allow the compression scheme to be trained jointly with the model’s parameters via gradient-based methods. For network training, we study alternatives to SGD and widely-used adaptive methods like Adam, specifically optimizers that leverage the model’s architecture to generate better parameter updates.

Formally, we consider the problem of optimizing network parameters $\theta\in\Theta$ to minimize a loss $\mathcal{L}:\Theta\to\mathbb{R}$. In particular, we assume that the model can be naturally expressed as a composition of intermediate functions

[TABLE]

which we call layers or nodes. In this case, $h^{(L)}$ denotes the model’s output, where $L$ is the model’s number of layers/nodes, or its depth, and $f_{l}$ is the function computed by node $l$ e.g., convolution, batch normalization.

Distinct optimization obstacles can arise in (1): for example, $f_{l}$ might be non-differentiable w.r.t. $\theta$, or discontinuous w.r.t. $h^{(l-1)}$, and so on. Each setting explored in this thesis contains an optimization obstacle whose root lies in (1) and which is treated in a unique fashion. Therefore, the content is split into sections, each discussing a different setting and a particular technique used to address its optimization challenges.

3 Organization and Contributions

The thesis is organized as follows:

• •

Chapter 2 (Preliminaries) provides a more detailed discussion on the goal of the thesis, delving deeper into the connection between overparameterization, model compression, and optimization. It also contains a guideline on how readers can modify or combine different approaches to tackle new problems.

Additionally, this chapter introduces key definitions and the notation adopted throughout the thesis. Finally, it reviews prior works that are related to at least two of the settings covered in each section. For example, it covers works on discrete optimization and on neural network training, which are common topics across different sections and settings.

• •

Chapter 3 (Neural Architecture Search via Parameter Sharing) considers the task of searching for efficient and well-performing neural network architectures in an automated fashion, in contrast to manual design performed by researchers which includes significant trial and error.

Neural Architecture Search (NAS) approaches architecture design by searching over a pool of candidates (search space) and selecting those that maximize some objective, such as a trade-off between accuracy and the model’s size. A naive approach would require fully training at least one model for each possible architecture, leading to prohibitive computational costs as the search space grows.

Designing cheap approximations for this problem is an active research area, and methods often rely on two key components to reduce the computational cost of NAS. First, reusing parameter configurations across different architectures, which enables different models to be trained jointly instead of independently and from scratch. Second, using partially-trained networks to perform evaluation and selection, resulting in sigificant computational cost savings.

Early methods adopted reinforcement learning and genetic algorithms to explore the search space and select a final architecture, as they can naturally tackle discrete decisions. However, these are computationally expensive since they do not employ continuous approximations for the discrete selection problem. Recent works offer significantly faster NAS by performing search with gradient-based methods – an approach that is made possible by adopting a continuous relaxation to the discrete problem.

The majority of NAS papers considers a search space with a rigid structure, where architectures consist of a pre-defined number of operations, each with a small number of possible configurations. For example, networks consisting of convolutional layers that can be either be depth-wise separable or not, and whose kernel size can be either 5 or 3. In contrast to prior works, we present a novel search space by incorporating recurrent connections to NAS, allowing networks to become better-suited for sequential tasks.

In particular, this chapter focuses on implicit recurrence in CNNs, allowing for CNN-RNN hybrids to emerge from the architecture search procedure and hence going beyond the standard static and feedforward search spaces. Instead of using parameter sharing for efficiency as in prior works, our method, originally published as Savarese and Maire (2019), frames the problem of searching for recurrent connections as one of learning parameter sharing schemes.

We approximate the discrete selection problem by employing a linear relaxation – a classical and flexible approach to approximate discrete optimization problems – where a variable’s discrete domain is extended by taking linear combinations of its possible values. In this setting, different architectures can be linearly combined which yields well-defined gradients w.r.t. the architecture itself. However, our method contains significant improvements over standard linear relaxation by leveraging information of the architectures to be searched.

Experiments on image classification show that our method can achieve significant parameter reduction while maintaining or even improving the original model’s performance on the CIFAR and ImageNet datasets. Furthermore, it can create hybrids between RNNs and CNNs with new and potentially beneficial architectural biases. A synthetic algorithmic task is designed and used to study these hybrid models, showing that recurrent connections emerge naturally during training and lead to faster adaptation and improved performance.

• •

Chapter 4 (Sparsification) discusses the process of removing unnecessary weights or neurons from a neural network, with the goal of creating a more efficient, sparse subnetwork whose performance is comparable to that of the original model.

The discrete nature of the problem comes from the binary decision of whether a parameter or neuron should be removed from the network. The number of possible configurations grows exponentially with the network size, making exact solutions intractable to compute.

Methods to approximate the search for sparse subnetworks often rely on heuristics to select which parameters to remove, for example removing weights with the smallest magnitude – a technique named magnitude pruning. Another family of techniques employ stochastic approximations, where the binary decisions are sampled from a distribution whose parameters are trained with gradient descent.

While heuristic methods like magnitude pruning rely on strong assumptions e.g., that a weight’s magnitude is a reliable proxy for its importance, they have proved successful in finding extremely sparse and efficient subnetworks. On the other hand, stochastic approaches aim to solve the original problem, but can suffer from training instabilities due to high variance caused by the additional stochasticity.

This chapter presents a simple and novel approach for sparsification that relies on a continuous and deterministic approximation, rather than using heuristics or stochastic proxies. Inspired by continuation methods, our approach, first published as Savarese et al. (2020), creates a homotopy between the original, intractable problem, and a smooth loss that can be optimized with gradient-based methods.

This homotopy can be seen as a path connecting a smooth loss functional – similar to standard network training objectives – to the computationally hard sparsification problem. It includes a temperature which is annealed during training, in such way that the objective is initially smooth and well-suited for SGD, and gets closer to the original problem as training progresses, effectively decreasing the approximation error while making optimization increasingly more difficult.

The discrete variables, which represent the removal of a parameter or neuron, are relaxed and re-parameterized into real-valued variables which can be trained jointly with the network’s weights. Since we adopt a fully deterministic approximation, no additional variance is introduced to the training dynamics, resulting in more stable and hence faster optimization.

The proposed method, Continuous Sparsification (CS), continuously sparsifies the network throughout training, and the removal of low importance weights is performed seamlessly by gradient descent. This is in contrast to prior approaches, where weights are either removed at pre-defined intervals (magnitude pruning) or only once the network has been fully trained (stochastic approximations), allowing for potential training cost reduction given specialized hardware.

Empirical studies on CIFAR and ImageNet show that CS produces networks that have been aggressively sparsified without noticeable impact to their performance. Moreover, its computational cost is significantly lower than competing methods, especially in the task of finding sparse subnetworks that can be successfully trained from scratch (ticket search).

• •

Chapter 5 (Quantization) studies the technique of limiting the number of bits used to represent a neural network’s parameters and intermediate activations, leading to immediate reductions to memory footprints and, given specialized hardware, faster training and inference times.

In neural network quantization, weights are typically stored in fixed-point representation with 8 bits or less, in contrast to standard, full-precision models with 32-bit floating point weights. The problem involves finding low precision values to represent the network, and training its quantized weights to maximize the performance under the precision constraints.

The discrete nature of the problem is two-fold: the number of bits used to represent the network is a positive integer, and the quantized weights can only assume a limited number of possible values – more specifically, $2^{p}$ possible configurations for a weight represented with $p$ many bits. Once again, the number of possible configurations for the discrete variables grows exponentially with the model’s size, hence finding optimal solutions is generally intractable.

Optimizing the precision values poses additional challenges compared to training the quantized weights, which the chapter discusses in detail. Because of this, most approaches assume a pre-defined and fixed precision for all parameters in a neural network, and focus on designing strategies to circumvent optimization obstacles caused by quantization constraints.

A simple yet effective approach to train quantized weights is to optimize real-valued weights using gradients w.r.t. their quantized forms i.e., using the straight-through estimator, a strategy that is commonly adopted in the quantization literature. Numerous works aim to further decrease the total precision required to represent a network by introducing architectural changes, such as carefully-designed full-precision pathways, that make the model more robust to quantization.

However, works that optimize the precision values used to represent a network’s weights remain scarce, especially in settings where parameter groups can be represented with different precision levels. Allowing for fine-grained precision assignments offers additional flexibility to possible compression schemes and can result in significant energy savings on specialized hardware. Moreover, the few works that fall in this category either rely on heuristics to assign precisions or employ costly strategies such as reinforcement learning, and are ill-suited to allocate a different precision to each weight – the finest level of granularity which offers the highest compression rates.

In contrast to prior works, the technique presented in this chapter is able to optimize precision values for a network’s weights and intermediate activations at any level of granularity – from all weights and activations being represented with the same number of bits, to the most fine-grained setting where distinct precisions are used to represent each weight and activation throughout the network. Additionally, the precisions are optimized jointly with the network’s weights via gradient descent, offering a simple yet modular approach to quantization.

The designed algorithm, Searching for Mixed-Precisions by Optimizing Limits for Perturbations (SMOL), was originally published as Savarese et al. (2022) and relies on a fundamental connection between quantization error and tolerance to random perturbations. In particular, the more a weight can be randomly perturbed without harming the network’s performance, the more aggressively it can be quantized by representing it with a lower precision. This correspondence is used to derive an approximation for the intractable precision assignment problem which is differentiable w.r.t. the precision variables and hence can be tackled with gradient descent.

Experimental evaluations on image classification, image generation, and machine translation show that SMOL can produce smaller, high-performing networks i.e., that require lower total precision to be represented while offering comparable or superior accuracy. Ablation experiments highlight potential benefits of fine-grained precision assignment and show that weights from the same layer can vastly differ in terms of quantization tolerance.

• •

Chapter 6 (Parameter Structure) is the last chapter of this thesis and focuses on more efficient optimizers for neural networks instead of compression methods. Designing better training algorithms for deep learning is an orthogonal and equally crucial approach to address the high resource costs of state-of-the-art models. This approach focuses directly on improving the efficiency of training, in contrast to compression methods which are better suited to reduce inference costs.

The chapter focuses on adaptive methods, a family of first-order optimization methods that is widely used in deep learning, often being necessary to successfully train models like RNNs and transformers. Unlike SGD, these methods designate dynamic learning rates for each parameter based on zeroth and first-order statistics, which can result in significantly fewer iterations required for training.

Although model compression techniques and adaptive methods are highly unrelated topics, they share similarities which are relevant in the context of this thesis. In particular, approximations are also a key component of adaptive optimization, however this is mostly restricted to a conceptual level: adaptive methods can be seen as approximations to higher-order optimizers.

Second-order methods offer superior convergence rates compared to gradient descent and are widely adopted when solving smaller optimization problems in real-world applications. However, the use of second-order information e.g., computing and inverting the Hessian matrix, is computationally unfeasible in deep learning, where models rarely have less than a million parameters. The dynamic learning rates computed by optimizers such as Adam involve the use of the gradient’s second moment, and can be seen as approximating the curvature adjustments provided by second-order methods while avoiding the computational costs of computing and inverting the Hessian.

Despite their wide use, adaptive methods offer worse generalization compared to SGD in some settings, and designing optimizers that are able to train complex networks while achieving comparable or better generalization has received significant attention. Moreover, adaptive optimizers typically do not take parameter structure into account when computing dynamic learning rates: their update equations do not consider each layer’s number of parameters, hence ignoring inherent differences between layers in a network.

This chapter discusses novel methods and results originally published as Savarese et al. (2021), and revisits theoretical properties of adaptive methods such as Adam, identifying limitations in terms of convergence guarantees and proposing modifications to overcome them. From a refined analysis of Adam’s convergence rate, we design AvaGrad, a novel adaptive method with better rates and which facilitates hyperparameter tuning.

An extensive empirical comparison between different adaptive methods, including tasks such as image classification with CNNs, language modeling with LSTMs, and image generation with GANs, shows that AvaGrad is capable of training models as fast as Adam while inducing generalization performance comparable to SGD’s. Moreover, we assess how easily each adaptive method can be tuned via hyperparameter optimization procedures and observe that AvaGrad can significantly reduce hyperparameter tuning costs compared to Adam.

Chapter 2 Preliminaries

4 Notation

Notation. For vectors $a=[a_{1},a_{2},\dots],b=[b_{1},b_{2},\dots]\in\mathbb{R}^{d}$ we use $\frac{1}{a}=[\frac{1}{a_{1}},\frac{1}{a_{2}},\dots]$ for element-wise division, $\sqrt{a}=[\sqrt{a_{1}},\sqrt{a_{2}},\dots]$ for element-wise square root, and $a\odot b=[a_{1}b_{1},a_{2}b_{2},\dots]$ for element-wise multiplication. $\left\lVert{a}\right\rVert$ denotes the $\ell_{2}$-norm, while other norms are specified whenever used.

The subscript $t$ is used to denote a vector related to the $t$-th iteration of an algorithm, while $i,j,k$ are used for coordinate indexing. Superscripts are always written in parentheses, and typically denote the layer index of a model’s activations or weights, e.g., $W^{(l)}$ represents the parameters associated with the model’s $l$-th layer. When used together, $t$ precedes coordinate-indexing subscripts: $W^{(l)}_{t,i}\in\mathbb{R}$ denotes the $i$-th coordinate of $W^{(l)}_{t}\in\mathbb{R}^{d}$.

For any $k\in\mathbb{N}$, we let $[k]=\{1,2,3,\dots,k\}$. We also denote the indicator function by

[TABLE]

Additionally, we refer to a $\mathbb{R}^{d}\to\mathbb{R}^{d}$ function $f$ as element-wise when for all $\theta\in\mathbb{R}^{d}$ and $i\in[d]$, $f(\theta)_{i}=f(\theta_{i})$. Finally, for any $\theta\in\Theta$, we let $\mathcal{D}_{\theta}$ be any distribution such that $\mathrm{supp}(\mathcal{D}_{\theta})\subseteq\Theta$, and $\mathcal{U}(S)$ denotes the uniform distribution over the set $S$.

5 Background

This section provides a broader context for the techniques explored throughout the thesis by discussing the core themes common to all sections in this thesis. While the specific chapters focus on distinct challenges such as neural architecture search, pruning, quantization, and adaptive optimization, they are all motivated by the central goal of improving the efficiency of deep learning models without harming their performance. Here, we elaborate on three recurring themes: efficiency, model compression, and parameter optimization.

5.1 Efficiency

The parameter counts of state-of-the-art models now commonly exceed hundreds of millions or even billions. While such overparameterized models often achieve superior performance, their computational and energetic costs have become major obstacles. As a result, designing techniques that can reduce these costs while preserving model performance has emerged as a key area of research.

In this context, efficiency refers to reducing resources such as memory, computation time, or power consumption required for training and inference. Approaches to improve efficiency vary significantly: from reducing the number of parameters or operations via sparsification or quantization to improving convergence rates during training through better optimizers. While these strategies differ in implementation, they share a common goal of decoupling model performance from brute-force scaling.

Throughout this thesis, we approach efficiency as a principled approximation problem. Rather than viewing performance and efficiency as opposites, we demonstrate that carefully designed approximations can yield models that are both compact and effective.

5.2 Model Compression

Model compression techniques aim to reduce the size and computational costs of deep networks by producing smaller, more efficient variants. The main forms of compression are sparsification, where unnecessary parameters are removed from the network, and quantization, where parameters are represented with few bits. Both of these strategies introduce discrete decisions into the overall optimization problem, such as whether to remove a weight or how many bits to allocate to a parameter.

The key challenge is that these discrete decisions are inherently non-differentiable and induce a combinatorial search space: evaluating all possible discrete configurations is unfeasible for large-scale models. Moreover, the optimal configuration is typically strongly coupled to the network’s parameters configurations which keep changing during training. Therefore, traditional approaches usually perform compression as a post-processing step, applied to a fully pre-trained network. This limits the extent to which compression schemes can contribute in terms of efficiency.

In contrast, this thesis investigates continuous approximations to these discrete problems, allowing the compression scheme itself to be trained jointly with the network parameters via gradient-based optimization. These methods are not only computationally cheaper but also enable dynamic compression throughout training.

5.3 Parameter Optimization

Another important approach for improving efficiency in deep learning is the development of better optimization methods. Training large neural networks is often constrained by the substantial number of iterations required by gradient-based methods, making the optimizer’s convergence speed and stability critical factors in reducing training costs.

Stochastic gradient descent (SGD) and its adaptive variants such as Adam have served as the backbone for training deep networks. However, these methods can be sensitive to hyperparameter configurations and often require extensive tuning across tasks. Moreover, recent works have shown that adaptive methods might fail to convergence due to suboptimal hyperparameter choices.

In this thesis, we study strategies for improving the convergence rates of adaptive methods while reducing their hyperparameter sensitivity. The goal is to reduce the computational costs associated with training and hyperparameter tuning, thereby making optimization a more efficient component of deep learning.

Chapter 3 Neural Architecture Search via Parameter Sharing

6 Introduction

6.1 Motivation & Strategy

This chapter introduces the first of several strategies in this thesis for enhancing the efficiency of deep learning systems. In particular, we study the design of more efficient neural architectures with the goal of maintaining performance while minimizing computational cost. Here, efficiency primarily refers to reductions in inference time and number of parameters – key factors in the deployment of large models.

Traditionally, architecture design has been a manual process based on trial and error (Chollet, 2017; Howard et al., 2017; Huang et al., 2017), requiring technical expertise and often being time-consuming. More recently, Neural Architecture Search (NAS) (Zoph and Le, 2017) has been proposed as a strategy to automate this process by framing it as an optimization problem: out of a large pre-defined search space of candidate architectures, choose one that meets a target performance level while minimizing resource requirements. However, the NAS objective is inherently discrete and combinatorial: choosing from all possible architectures is computationally infeasible, as each candidate requires a complete training cycle before it can be evaluated. Therefore, most existing NAS approaches focus on designing methods to reduce the costs of architecture search – these are discussed in Section 6.2.

We first formalize this computationally hard optimization problem in Section 7.1, discussing how the combinatorial nature of NAS impacts efficiency. Section 7.2 re-frames the original problem in an equivalent form that is more amenable to approximations. Then, in Section 7.3, we present an efficient approximation that forms the basis of our NAS method and further elaborate on how we can produce architectures with backward connections. Subsequent sections outline our experimental setup, report empirical results, and offer a detailed analysis of our method, including a discussion of its contributions and impacts.

6.2 Related Work

Architecture Search.

Early efforts to design efficient neural architectures typically relied on manual design and experimentation (Iandola et al., 2016; Zhu et al., 2018). For example, Chollet (2017) shows that separable convolutions can reduce computational costs significantly while matching the performance of standard convolutions. Subsequently, architectures like MobileNet (Howard et al., 2017; Sandler et al., 2018) and ShuffleNet (Zhang et al., 2018b) employ factorizations or groupings over convolutions to improve the inference time of CNNs.

Newer approaches aim to automate architecture design, a task referred to as Neural Architecture Search (NAS). Zoph and Le (2017) and Zoph et al. (2018) use reinforcement learning to search over large spaces, discovering architectures that outperform hand-designed ones. Although the produced networks offer superior efficiency, the search phase is computationally expensive and requires thousands of GPU hours. More recent works adopt continuous relaxations that yield more efficient search algorithms, such as DARTS (Liu et al., 2019), ENAS (Pham et al., 2018), and SNAS (Xie et al., 2019).

Both manual design approaches and automated NAS strategies share the common goal of optimizing a trade-off between accuracy and efficiency. The method proposed in this chapter advances this research topic by providing a novel approximation to search over a new and complex search space.

CNN-RNN Hybrids.

Combining convolutional neural networks (CNNs) and recurrent neural networks (RNNs) has been explored at a broad structural level, where a hybrid but fixed architecture is hand-designed to operate on a sequence of spatial features. Such hybrids have proven successful in multiple settings, including scene labeling (Pinheiro and Collobert, 2014), image captioning with attention (Xu et al., 2015), and video understanding (Donahue et al., 2015). Generic hybrid models, such as convolutional LSTMs and feedback networks, have also been proposed as versatile architectures that can be applied in a plug-and-play fashion on diverse domains. Even for non-sequential tasks like image classification, enforcing layer reuse throughout a CNN allows for parameter reduction, although at the cost of some performance degradation (Köpüklü et al., 2019).

Studies on residual networks (He et al., 2016a) suggest that introducing residual connections to CNNs results in intriguing parallels to RNNs. In particular, Greff et al. (2017) show that residual blocks may refine hidden representations through iterative processes, similar to unrolled loops that RNNs represent. Boulch (2017) propose residual architectures where different layers explicitly reuse parameters, effectively inducing a rigid recurrence mechanism. Similarly, Jastrzebski et al. (2018) explore layer reuse and iterative processes within residual networks, further establishing connections to recurrent architectures.

Hypernetworks and Algorithmic Architectures.

Some lines of research explore the idea of hypernetworks (Ha et al., 2016), where one network (the ‘hypernetwork’) generates or modifies the weights of another model (the ‘trunk network’), leading to more flexible or dynamic architectures. This decoupling of parameters from layers in the trunk network facilitates parameter sharing across modules or tasks, and opens up new possibilities for meta-learning and memory footprint reduction. Our proposed mechanism can be seen as a minimal hypernetwork in which weights are generated via a simple linear combination.

Another relevant body of work attempts to design more algorithmic or ‘program-like’ architectures. Neural Turing Machines (NTMs) (Graves et al., 2014) and Differentiable Neural Computers (DNCs) (Graves et al., 2016) introduce ways to write and read information from an external memory, enabling models to present algorithmic behavior such as copying and sorting data. A key, shared component among these architectures is the repeated call of modules in a loop, which resemble subroutine calls in classical programming.

In contrast to previous NAS works, our method adopts a search space where architectures are allowed to have backward connections. This results in networks whose layers can be ‘executed’ multiple times, much like a computer program that invokes the same function repeatedly. Although our approach adopts simple weight sharing across layers, it yields models with a more structured and algorithmic behavior, in a similar flavor to NTMs and DNCs.

7 Method

7.1 Formalizing the Architecture Search Problem

The search problem we address involves selecting an architecture from a pool of candidates that minimizes a given metric while meeting a set of constraints. We refer to this pool as the search space. By design, it does not assume any structure or impose constraints on the architectures beyond matching the input and output shapes prescribed by the dataset.

Throughout this chapter, we assume a fixed dataset $D$ that is chosen a-priori, which may contain both samples and labels in a supervised setting or just samples in an unsupervised scenario. In either case, our formulation of the architecture search problem and our proposed method’s details do not depend on the nature of the underlying task.

We let $f:\theta_{f}\to f(\theta_{f})$ denote a neural architecture and $\Theta_{f}$ be its weight space, such that for any $\theta_{f}\in\Theta_{f}$, $f(\theta_{f})$ represents a network (the architecture $f$ equipped with weight values $\theta_{f}$ that align with $f$’s structure). For any sample in $D$, $f(\theta_{f})$ produces an output that aligns with the task at hand (e.g., a class label or a reconstruction). We further define $\mathcal{L}:f(\theta_{f})\to\mathcal{L}(f(\theta_{f}))\in\mathbb{R}$ as the loss function that evaluates the network $f(\theta_{f})$ on the dataset $D$ (omitting $D$ in the notation for brevity). The search space $\mathcal{F}$ is a discrete set of architectures consistent with the task, in terms of input and output dimensions.

We can then formalize the architecture search problem as follows:

Definition 3.1** (Architecture Search Problem).**

Let $\mathcal{F}$ be a discrete set of architectures, and for each $f\in\mathcal{F}$, let $\Theta_{f}$ be its weight space. For any $\theta_{f}\in\Theta_{f}$, $\mathcal{L}(f(\theta_{f}))\in\mathbb{R}$ denotes the loss incurred by $f(\theta_{f})$ on the fixed dataset $D$. Then, the architecture search problem is:

[TABLE]

Two constrained variants of the problem above are (1) minimizing $\mathcal{L}(f(\theta_{f}))$ subject to a constraint on the network cost $C(f(\theta_{f}))\leq\tau$, and (2) minimizing $C(f(\theta_{f}))$ (to find the most efficient network) subject to $\mathcal{L}(f(\theta_{f}))\leq\tau$. Although these formulations are natural ways to include cost constraints in architecture search, most works focus on the unconstrained problem, typically assuming that all architectures in $\mathcal{F}$ are sufficiently efficient so that explicit cost constraints become redundant.

Search Spaces.

The general architecture search problem, as framed above, leaves limited scope for practical approximations or efficiency improvements unless we specify additional structure for the search space. Leveraging similarities or redundancies among potential architectures allows us to reduce the combinatorial cost that is inherent in the original problem.

In most NAS methods, $\mathcal{F}$ follows a rigid, feedforward structure: the architectures have a fixed number of blocks $L\in\mathbb{N}$, and each block is chosen from a set $\mathcal{H}=(h^{(1)},\dots,h^{(k)})$ of candidate functionals (or ‘block types’).

Here, each block type $h\in\mathcal{H}$ is typically a short sequence of common layers in deep learning (e.g., convolution + batch normalization + non-linear activation). In this setting, the instantiation of distinct architectures comes from specifying which block type from $\mathcal{H}$ occupies each position in the network.

Definition 3.2** (Functional Search Space).**

Given $L,k\in\mathbb{N}$, let $\mathcal{H}=(h^{(j)})_{j=1}^{k}$ be a set of functionals associated with a weight space $\mathcal{W}$. Suppose any $h,h^{\prime}\in\mathcal{H}$ can be composed when equipped with weights $W,W^{\prime}\in\mathcal{W}$. We define the functional search space $\mathcal{F}_{F}$ as

[TABLE]

where the weight space of each architecture $f\in\mathcal{F}_{F}$ is $\Theta_{f}=\mathcal{W}^{L}$.

As a concrete example, consider:

[TABLE]

where Id is the identity mapping. For a specified depth $L\in\mathbb{N}$, there are $3^{L}$ architectures in the induced search space $\mathcal{F}_{F}$. These include, for instance, the identity mapping at all $L$ blocks, an all $3\times 3$ convolution stack, or an alternating sequence of $3\times 3$ and $5\times 5$ convolutions.

We propose a different search space that supports backward connections and layer reuse. Instead of defining $L$ unique blocks, we allow architectures to compose a smaller set of $k\in\mathbb{N}$ layer configurations in various sequences, resulting in $k$ total weight tensors $W^{(1)},\dots,W^{(k)}$. While the network depth may still be $L$, any of the $k$ layer configurations can appear multiple times in the network. In a sense, our search space allows for the architecture’s topology to be learned.

Definition 3.3** (Topological Search Space).**

Given $L,k\in\mathbb{N}$, let $(h^{(l)})_{l=1}^{L}$ be a sequence of functionals associated with a weight space $\mathcal{W}$. Suppose any $h^{(l)},h^{(l-1)}$ can be composed when equipped with weights $W,W^{\prime}\in\mathcal{W}$. We define the topological search space $\mathcal{F}_{T}$ as

[TABLE]

where the weight space of each architecture $f\in\mathcal{F}_{T}$ is $\Theta_{f}=\mathcal{W}^{k}$.

This ‘topological’ search space incorporates one aspect of programmatic modularity, allowing the architecture to reuse a layer configuration at arbitrary depths. Performing architecture search over our search space amounts to effectively optimizing ‘loop lengths’ (i.e., how many times a configuration is repeated), and the content of these loop-like constructs (layer configurations). This enables architectures with a more ‘program-like’ structure to be produced, which already brings notable gains compared to feedforward baselines.

Though recurrent neural networks (RNNs) do incorporate a loop-like structure by design, their loop length is fixed rather than learned, leading to potential mismatches with the underlying task. In contrast, our approach allows coexistence of loops and feed-forward layers in the same architecture. For example, a search over 50-layer architectures might produce a two-layer loop that repeats five times between layers 10 and 20, a three-layer loop that repeats four times from layers 30 to 42, and otherwise assign independent weights to the remaining layers. By integrating feed-forward and recurrent architectures under the same space, our method forms a natural hybrid, allowing for richer topologies that can more flexibly adapt to the underlying task.

7.2 Re-framing the Architecture Search Problem

The functional and topological search spaces presented in Definitions 3.2 and 3.3 have a useful property: each architecture is uniquely determined by a configuration $\alpha\in[k]^{L}$. In the functional space $\mathcal{F}_{F}$, $\alpha$ induces an architecture by specifying which block type $h\in\mathcal{H}$ appears in each of the $L$ positions. In the topological space $\mathcal{F}_{T}$, $\alpha$ instead dictates which of the $k$ weight tensors is used at each step in the forward pass. Formally, we denote by $f_{\alpha}$ the architecture corresponding to a configuration $\alpha\in[k]^{L}$.

Another important observation is that, once $L$ and $k$ are fixed, all architectures in these search spaces share the same weight space $\Theta$. In other words, for any pair of architectures $f,f^{\prime}\in\mathcal{F}$, we have $\Theta_{f}=\Theta_{f^{\prime}}=\Theta$. This follows from the fact that each block type (or layer module) is defined on a uniform parameter domain, even for functions like the identity mapping.

By leveraging these two observations, we can recast the original architecture search problem (Definition 3.1) in an equivalent, but more structured, form. Instead of optimizing over $f\in\mathcal{F}$ and $\theta_{f}\in\Theta_{f}$, we optimize over integer architectural identifiers $\alpha\in[k]^{L}$ and a single parameter configuration $\theta\in\Theta$:

Definition 3.4** (Re-framed Architecture Search Problem).**

Let $\mathcal{F}$ be either the functional or topological search space from Definitions 3.2 and 3.3. Given fixed $L,k\in\mathbb{N}$, define for each $\alpha\in[k]^{L}$ the unique architecture $f_{\alpha}=\mathcal{F}(\alpha)\in\mathcal{F}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, the architecture search problem can be rewritten as

[TABLE]

which is equivalent to the problem in Definition 3.1.

Although restating the search space in terms of ‘architectural variables’ $\alpha\in[k]^{L}$ and a shared weight tensor $\theta\in\Theta$ makes the structure more explicit, it remains a discrete (integer) optimization problem and is as computationally hard as the original. However, this formulation is naturally suited to approximation techniques for integer programs. In the next section, we leverage these ideas to relax the discrete domain and obtain an efficient approximation.

7.3 Approximating the Architecture Search Problem

In the previous section, we re-framed the architecture search problem by introducing an architectural configuration $\alpha\in[k]^{L}$ that induces the network topology. While this recasting makes the task more structured, it remains an integer optimization problem and hence intractable. Now, we approximate the problem by relaxing the discrete domain of $\alpha$, thus rendering the overall optimization problem continuous and amenable to gradient-based methods.

Recall from Definition 3.3 that in the topological search space $\mathcal{F}_{T}$, each block in the network implements a function $h(W^{(\alpha_{l})})$, where $\alpha_{l}\in[k]$ dictates which of the $k$ weight tensors to use. We now define a relaxed version of $\mathcal{F}_{T}$, denoted $\overline{\mathcal{F}}_{T}$, in where we replace the discrete weight selection with a linear combination of all weights.

Definition 3.5** (Relaxed Topological Search Space).**

Given $L,k\in\mathbb{N}$, let $(h^{(l)})_{l=1}^{L}$ be a sequence of functionals associated with a weight space $\mathcal{W}$. Suppose any $h^{(l)},h^{(l-1)}$ can be composed when equipped with weights $W,W^{\prime}\in\mathcal{W}$. We define the relaxed topological search space $\overline{\mathcal{F}}_{T}$ as

[TABLE]

where $\alpha=(\alpha^{(l)})_{l=1}^{L}$ and the weight space of each architecture $f\in\overline{\mathcal{F}}_{T}$ is $\Theta_{f}=\mathcal{W}^{k}$.

Here, each $\alpha^{(l)}$ is a real-valued vector that combines the $k$ weight templates $(T^{(i)})_{i=1}^{k}$ in a linear fashion. As before, each configuration $\alpha\in(\mathbb{R}^{k})^{L}$ uniquely identifies an architecture $f_{\alpha}=\overline{\mathcal{F}}_{T}(\alpha)\in\overline{\mathcal{F}}_{T}$. In this setting, we denote the shared weight templates as $T$ rather than $W$ to emphasize their distinct role: they are not directly used as effective weights by the layers, but rather serve as components that are linearly combined – via the mixing coefficients $\alpha$ – to generate the effective weights $W$.

Note that the original topological search space $\mathcal{F}_{T}$ is recovered as a special case if each $\alpha^{(l)}$ is constrained to belong to the standard $k$-dimensional basis $(e^{(j)})_{j=1}^{k}\subset\mathbb{R}^{k}$, where $e^{(j)}$ is the all-zeros vector except for a 1 in position $j$. In this setting, the linear combination acts as a hard selection since $\sum_{i=1}^{k}e^{(j)}_{i}T^{(i)}=T^{(j)}$, and hence $\overline{\mathcal{F}}_{T}(\alpha)\in\mathcal{F}_{T}$.

More formally, denoting the standard $k$-dimensional basis by

[TABLE]

we have that

[TABLE]

and thus $\mathcal{F}_{T}\subset\overline{\mathcal{F}}_{T}$.

Therefore, we can use $\overline{\mathcal{F}}_{T}$ to express the original search problem over $\mathcal{F}_{T}$ in an equivalent way – but still with discrete variables $\alpha$:

[TABLE]

This version simply restates Definition 3.4 using the relaxed topological search space $\overline{\mathcal{F}}_{T}$, which behaves exactly like $\mathcal{F}$ under the above domain constraints on the variables $\alpha$.

Finally, we employ our approximation by relaxing the domain of each $\alpha^{(l)}$ to \text{span}\big{(}\mathbb{B}^{k}\big{)}=\mathbb{R}^{k} (or some other continuous subset, such as \text{hull}\big{(}\mathbb{B}^{k}\big{)} or the $k$-simplex). Formally,

Definition 3.6** (Approximate Architecture Search Problem).**

Let $\overline{\mathcal{F}}_{T}$ be the relaxed topological search space from Definition 3.5. Given fixed $L,k\in\mathbb{N}$, define for each $\alpha\in(\mathbb{R}^{k})^{L}$ the unique architecture $f_{\alpha}=\overline{\mathcal{F}}_{T}(\alpha)\in\overline{\mathcal{F}}_{T}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, the approximate architecture search problem is

[TABLE]

Here, each block’s effective weights become a learnable linear combination of the weight templates $\theta=(T^{(i)})_{i=1}^{k}$. Because $\alpha$ and $\theta$ are both continuous and real-valued, the entire system can be trained end-to-end with gradient-based methods such as SGD. This yields a continuous approximation to the original architecture search problem.

7.4 The Proposed Architecture Search Method

In practice, we treat $\alpha=(\alpha^{(l)})_{l=1}^{L}$ and $\theta=(T^{(i)})_{i=1}^{k}$ as joint parameters of a ‘super architecture’ $\overline{f}:(\alpha,\theta)\mapsto\overline{\mathcal{F}}_{T}(\alpha)(\theta)$. We then train them simultaneously using standard gradient-based optimization methods (e.g., Adam, SGD). By doing so, we effectively learn:

• •

Which ‘mix’ of weight templates each layer uses ($\alpha^{(l)}$), and

• •

The weight templates themselves ($T^{(i)}$)

Although the relaxed formulation no longer forces a discrete template selection at each layer, architectures from $\mathcal{F}_{T}$ can still emerge in practice if each $\alpha^{(l)}$ converges to a one-hot vector. Concretely, one may view each layer $l$ as still having its own weights $W^{(l)}$, but rather than being free parameters, they are given by a linear combination of weight templates:

[TABLE]

Hence, our approximation can also be seen as a soft-parameter sharing scheme in which each layer has access to all weight templates $(T^{(i)})_{i=1}^{k}$, and the sharing mechanism is governed by the soft selection given by $(\alpha^{(l)})_{l=1}^{L}$.

Figure 1 (left) depicts a two-layer feedforward CNN where each convolutional layer $l$ has its own weight tensor $W^{(l)}$. In contrast, Figure 1 (middle) illustrates our soft parameter sharing scheme for the same CNN. Here, the weight templates $T^{(1)},T^{(2)}$ are shared globally, and each layer $l$ has only a two-dimensional parameter vector ${\alpha}^{(l)}$. The effective weights $W^{(l)}$ (shown with dotted boxes to indicate they are no longer free parameters) are then generated by combining the templates $T^{(1)},T^{(2)}$ with ${\alpha}^{(l)}$.

Additionally, this approach decouples the number of weight templates $k$ from the network’s depth $L$. Specifically, an $L$-layer CNN trained with soft-sharing has $O(kC^{2}K^{2})$ total parameters, compared to $O(LC^{2}K^{2})$ without sharing. As we will see, one application of this method is to reduce the parameter count of deep models.

Interpretation.

Because convolution and matrix multiplication are both linear operations, one can also view our scheme as learning template layers that are shared across a network in a soft manner. Formally, if $u^{(l)}$ denotes the output of the $l$-th layer, then

[TABLE]

where $T^{(i)}u^{(l-1)}$ can be interpreted as the output of a template layer $\tilde{u}^{(i)}$ with individual parameters $T^{(i)}$ and input $u^{(l-1)}$. These template layers $\tilde{u}^{(1)},\dots,\tilde{u}^{(k)}$ act as global feature extractors, and the coefficients $\alpha^{(l)}$ specify which features to use at the $l$-th computation. Figure 1 (right) depicts this new view for a two-layer CNN: two template convolutions extract features that are combined at each step via $\alpha^{(l)}$.

This perspective reveals a direct connection between $\alpha$ and the network’s topology. For instance, if $\alpha^{(l)}=\alpha^{(l^{\prime})}$ for some $l<l^{\prime}$, then layers $l$ and $l^{\prime}$ are functionally equivalent (they implement the same mapping). In such case, we can rewire the network by sending the output of layer $l^{\prime}-1$ to layer $l$, and then passing the output of layer $l$ (on its second execution) to layer $l^{\prime}+1$. This results in an equivalent network and allows for the removal of layer $l^{\prime}$. Unlike standard models, this ‘folded’ network has backward connections, and each layer’s output may feed into different layers based on its execution step.

Network Folding.

The folding process can also be applied approximately, when two layers are only similar rather than identical, however at risk of performance degradation. Since functional similarity between layers depends on their effective weights $W^{(l)}$, we can directly compare the low-dimensional vectors $\alpha^{(l)}$ instead of induced mappings. Specifically, we can build an $L\times L$ layer similarity matrix (LSM) $S$, where $S_{l,l^{\prime}}$ is the similarity between the coefficients $\alpha^{(l)}$ and $\alpha^{(l^{\prime})}$.

When batch normalization (Ioffe and Szegedy, 2015) (or other normalization layer) is used, a layer’s output becomes invariant to rescaling of its weights. Thus, if $\alpha^{(l)}=c\cdot\alpha^{(l^{\prime})}$ for $c\in\mathbb{R}_{>0}$, layers $l$ and $l^{\prime}$ will turn out to be functionally equivalent. Even if $c\in\mathbb{R}_{<0}$, we can still merge the layers by negating its input at the appropriate step.

A natural metric that is invariant to rescaling is the absolute cosine similarity:

[TABLE]

Figure 2 shows examples of the LSM:

• •

(Left) A network without parameter sharing shows little to no similarity across layer weights.

• •

(Middle) With soft parameter sharing, layers often end up functionally similar, indicated by the shared color of their coefficients and effective weights

• •

(Right) By folding these layers, we produce a more compact architecture featuring backward connections and self-loops.

Reparameterization.

Although we have relaxed our problem such that each $\alpha^{(l)}\in\mathbb{R}^{k}$, there might be cases where we want produce an architecture from the original topological search space $\mathcal{F}_{T}$. Recall that, if each $\alpha^{(l)}\in\mathbb{B}^{k}$ (i.e., is one of the standard basis vectors of $\mathbb{R}^{k}$), then $\overline{\mathcal{F}}_{T}(\alpha)\in\mathcal{F}_{T}$, so we can produce $f\in\mathcal{F}$ by simply ‘rounding’ each $\alpha^{(l)}\in\mathbb{R}^{k}$ to a standard basis vector.

If done naively, this rounding is likely to cause significant performance degradation since learned vectors $\alpha^{(l)}$ are typically far from one-hot vectors. However, unlike most approximated integer optimization problems, our setup allows for a reparameterization that can decrease the rounding error significantly.

Specifically, given a set of trained variables $(\alpha^{(l)})_{l=1}^{L},(T^{(i)})_{i=1}^{k}$, we can reparameterize them while preserving each layer’s effective weights and hence the behavior of the network:

Proposition 3.1**.**

Let $(\alpha^{(l)})_{l=1}^{L}\in(\mathbb{R}^{k})^{L}$ and $(T^{(i)})_{i=1}^{k}\in\mathcal{W}^{k}$ be mixing coefficients and weight templates of a model trained with soft parameter sharing. Let $\alpha\in\mathbb{R}^{k\times L}$ and $T\in\mathbb{R}^{k\times d}$ be the matrices containing all variables. Given a $k\times k$ invertible matrix $B$, let

[TABLE]

then the network with coefficients $\alpha^{\prime}$ and templates $T^{\prime}$ is equivalent to the original one, as in the effective weights of each layer $l$ are the same.

One strategy to leverage the reparameterization above is as follows:

After training, compute the LSM matrix and group together layers that are sufficiently similar. Let $g_{l}\in\mathbb{N}$ denote the group of the $l$-th layer and $n$ the total number of groups. 2. 2.

Construct new coefficients $\alpha^{\prime}$, setting ${\alpha^{\prime}}^{(l)}=e^{(g_{l})}$ for each $l\in[L]$. 3. 3.

Compute the transposed reparameterization matrix $B^{T}=\alpha{\alpha^{\prime}}^{T}(\alpha^{\prime}{\alpha^{\prime}}^{T})^{-1}$. 4. 4.

Create new weight templates $T^{\prime}=BT$.

Note that if $n<k$, then we only keep the first $n$ rows of $\alpha^{\prime}$, making it a $n\times L$ matrix. This results in $B$ being $n\times k$, and $T^{\prime}$ containing only $n<k$ templates, as expected, since only $n$ templates are needed to fully represent the network.

As a concrete example, consider, for $L=5$ and $k=4$,

[TABLE]

which yields the LSM (up to 2 decimals)

[TABLE]

Then, we can create group 1 containing layers 1 and 3, group 2 containing layers 2 and 4, and group 3 containing layer 5. Since we ended up with $3<4=k$ groups, the new coefficient matrix will be $3\times 4$:

[TABLE]

Next, we compute the reparameterization matrix:

[TABLE]

and, finally, create the new templates $T^{\prime}=BT$. This procedure preserves the network functionality and transforms its coefficients $\alpha$ such that it can be directly mapped to an architecture from the original topological search space $\mathcal{F}_{T}$.

Recurrence Regularizer.

While layer similarities might emerge naturally, it may be desirable to encourage explicit recurrencies. One way to achieve this is by introducing a regularizer to the loss, pushing parameters to configurations that result in more loops. For example, we can penalize the sum of the LSM’s elements:

[TABLE]

where $\lambda$ controls the regularizer’s strength. As $\lambda$ grows, the entries of $S$ are driven closer to 1. In the extreme, every pair of layers becomes functionally equivalent, effectively collapsing the network into a single layer and a self-loop.

8 Experimental Setup

In this section, we describe the datasets, models, training protocols, and evaluation metrics used in our experiments. Our primary goal is to compare the accuracy and parameter efficiency of models trained with soft parameter sharing against standard architectures and established architecture search methods.

8.1 Datasets

CIFAR-10 and CIFAR-100.

The CIFAR-10 and CIFAR-100 datasets (Krizhevsky, 2009) consist of $32\times 32$ color images. CIFAR-10 includes 50,000 training images and 10,000 test images, split across 10 classes, while CIFAR-100 has 100 classes but retains the same training/test splits. We apply standard channel-wise normalization using statistics computed from the training set, followed by the data augmentation procedure of He et al. (2016a), which involves random crops and horizontal flips.

ImageNet.

For ImageNet (Russakovsky et al., 2015), we use the ILSVRC 2012 subset containing approximately 1.28 million training images and 50,000 validation images across 1,000 different object classes. We use single $224\times 224$ center-crop images during both training and validation. Following Gross and Wilber (2016), our data augmentation includes random scaling (extracting crops of varying aspect ratios/sizes and upsampling with bicubic interpolation), photometric distortions (random brightness, contrast, and saturation changes), lighting noise, and horizontal flips. We also apply channel-wise normalization using statistics from a sampled subset of the training set.

Synthetic Shortest-Paths Task.

We additionally design a synthetic shortest-paths task to evaluate the extrapolation capacity of implicitly recurrent models. Each sample is a $32\times 32$ grid containing two randomly placed query points and several obstacles, encoded in two binary channels: the first channel indicates query points, and the second indicates obstacles. Except for the two query points, each pixel has $10\%$ probability of containing an obstacle. The objective is to label all pixels that belong to at least one shortest path between the two query points. We generate five sets of 5,000 samples each, forming a curriculum that increases the maximum distance between the two query points by increments of 2, and starting from an initial distance of 2 (including diagonal movements).

8.2 Models

Baseline CNN Architectures.

We use Wide ResNets (WRNs) (Zagoruyko and Komodakis, 2016) as our main baselines for CIFAR-10, CIFAR-100, and ImageNet. WRNs extend pre-activation ResNets (He et al., 2016b) by scaling the number of channels by a “widen” factor. We denote these models as WRN-L-w, where $L$ is the number of layers and $w$ is the widen factor. In addition, we include ResNeXts (Xie et al., 2017) and DenseNets (Huang et al., 2017) as stronger baselines.

Soft-Shared Wide ResNet (CIFAR).

Directly sharing parameters across all convolutions in a WRN is not possible because layers have varying input/output channel dimensions. Instead, we group together convolutional layers that share the same input/output channel dimensions, enabling them to share a common set of weight templates. This ensures the shapes of the weight templates remain compatible with the convolution’s input/output dimensions.

CIFAR WRNs begin with an initial $3\times 3$ convolution followed by three stages. Each stage has an initial depth-increasing residual block (which contains two sequential $3\times 3$ convolutions and a convolutional residual connection), and several depth-preserving residual blocks (each with two $3\times 3$ convolutions).

Since the first block in each stage differs in input/output depth, we exclude it from parameter sharing. The remaining convolutions in each stage have matching input/output depth, hence we group them together to share parameters. Formally, if there are $\frac{L-1}{3}$ convolutions per stage, excluding the first block leaves $\frac{L-1}{3}-3=\frac{L-10}{3}$ convolutions in each of the three groups. We let SWRN-L-w-k denote a WRN with $L$ layers, widen factor $w$, and $k$ weight templates shared per group. If $k=\frac{L-10}{3}$, then we have as many shared weights as convolutions per group, so there is no parameter reduction relative to a standard WRN. In this case, we omit the $k$ value and simply write SWRN-L-w. We use WRN-28 as the base architecture for most CIFAR experiments, which has six convolutions per group.

Soft-Shared Wide ResNet (ImageNet).

Wide ResNets on ImageNet feature four stages, each composed of bottleneck residual blocks with three convolutions: a depth-decreasing, a depth-preserving, and a depth-increasing layer. To share parameters across this structure, we divide each stage into three groups, one for each type of convolution (depth-decreasing, depth-preserving, depth-increasing), while again excluding the first block of each stage from sharing – this yields a total of 12 groups across the four stages.

For our ImageNet experiments, we use WRN-50, which has 3, 4, 6, and 3 bottleneck blocks in each of its four stages, respectively. Our variant with parameter sharing allocates as many weight templates for each group as its number of convolutional layers, hence there is no parameter reduction. Any accuracy improvements would primarily arise from faster/better training dynamics or architectural bias.

NAS Baselines.

We also compare our approach against established NAS methods that adopt a standard feed-forward search space, including NASNet, AmoebaNet, DARTS, SNAS, and ENAS. This highlights how our implicit recurrence search method fares in relation to established NAS strategies.

CNN for Synthetic Task.

For the synthetic shortest-paths task, we employ a 22-layer CNN: one $1\times 1$ convolution mapping 2 input channels to 32, followed by 20 depth-preserving $3\times 3$ convolutions (each followed by batch normalization (Ioffe and Szegedy, 2015) and ReLU (Nair and Hinton, 2010)), and a final $1\times 1$ convolution mapping 32 channels to 1. All $3\times 3$ convolutions have a skip connection. For the soft-shared variant, we assign 20 weight templates across the 20 $3\times 3$ convolutional layers.

8.3 Training

CIFAR-10 and CIFAR-100.

For our CIFAR experiments, we train each model for 200 epochs using SGD with a Nesterov momentum of 0.9. The initial learning rate is set to 0.1 and is reduced by a factor of 5 at epochs 60, 120, and 160. We use a batch size of 128 on a single GPU, applying a weight decay of 0.0005 to all parameters except the soft-sharing coefficients $\alpha$. Convolutional filters and weight matrices are initialized using Kaiming initialization.

ImageNet.

Following Gross and Wilber (2016) and Zagoruyko and Komodakis (2016), we use SGD with a Nesterov momentum of 0.9 and train for 100 epochs. The learning rate starts at 0.1 and is decayed by a factor of 10 at epochs 30, 60, and 90. We use a total batch size of 256, distributed evenly across 4 GPUs. As with CIFAR, Kaiming initialization is applied to all convolutional filters, and no weight decay is applied to the coefficients $\alpha$. For the remaining parameters, we use a weight decay of 0.0001.

Synthetic Shortest-Paths Task.

We use Adam (Kingma and Ba, 2015) with a learning rate of 0.01, training for 50 epochs at each of the 5 curriculum phases. In each phase, the maximum distance between the two query points increases, making the task more challenging. Convolutional filters are again initialized via Kaiming’s scheme, and we do not apply weight decay in these experiments.

8.4 Evaluation

Test Accuracy and Top-1/Top-5 Accuracy.

For the CIFAR datasets, we measure and report the accuracy on the 10,000 test samples. On ImageNet, we use the top-1 and top-5 accuracy on the 50,000 validation images. Top-5 accuracy is the fraction of samples for which the true label appears among the top five predicted classes.

Number of Parameters.

We track the total number of parameters in each model to gauge memory efficiency, highlight potential parameter savings, and compare storage costs among different approaches.

Architecture Search Time.

When comparing against NAS methods, we track the total training time to perform architecture search and output a final, trained model.

F1 Score.

For the synthetic shortest-paths task, we adopt the F1 score as metric instead of accuracy due to the significant class imbalance (most cells in the grid do not belong to at least one shortest path). It is defined as

[TABLE]

where $y,\hat{y}$ are the vectors containing the true and predicted label for a set of samples and $\mathbbm{1}\{\cdot\}$ is the indicator function.

9 Results

9.1 Improving Network Efficiency

CIFAR:

Tables 1 and 2 present results on CIFAR. Networks trained with our method yield superior performance in the setting with no parameter reduction: SWRN 28-10 presents $6.5\%$ and $2.5\%$ lower relative test errors compared to the base WRN 28-10 model on CIFAR-10 and CIFAR-100, suggesting that our method aids optimization since both models have the same capacity.

With fewer templates than layers, SWRN 28-10-1 (all 6 layers of each group perform the same operation), performs virtually the same as the base WRN 28-10 network, while having $\frac{1}{3}$ of its parameters and less capacity. On CIFAR-10, parameter reduction ($k=2$) is beneficial to test performance: the best performance is achieved by SWRN 28-18-2 (3.43% test error), outperforming the ResNeXt-29 16x64 model (Xie et al., 2017), while having fewer parameters (55M against 68M) and no bottleneck layers.

Figures 3 and 4 show that our parameter sharing scheme uniformly improves accuracy-parameter efficiency on CIFAR-10 and CIFAR-100. Comparing the WRN model family (solid red) to our SWRN models (dotted red), we see that SWRNs are significantly more efficient than WRNs. DN and RNX denotes DenseNet and ResNeXt, respectively, and are plotted for illustration: both models employ orthogonal efficiency techniques, such as bottleneck layers.

Table 3 presents a comparison between our method and neural architecture search (NAS) techniques (Zoph and Le, 2017; Xie et al., 2019; Liu et al., 2019; Pham et al., 2018; Real et al., 2018) on CIFAR-10 – results differ from Table 1 solely due to cutout (DeVries and Taylor, 2017), which is commonly used in NAS literature; NAS results are quoted from their respective papers. Our method outperforms architectures discovered by recent NAS algorithms, such as DARTS (Liu et al., 2019), SNAS (Xie et al., 2019) and ENAS (Pham et al., 2018), while having similarly low training cost. We achieve $2.69\%$ test error after training less than $10$ hours on a single NVIDIA GTX 1080 Ti. This accuracy is only bested by NAS techniques which are several orders of magnitude more expensive to train. Being based on Wide ResNets, our models do, admittedly, have more parameters.

Comparison to recent NAS algorithms, such as DARTS and SNAS, is particularly interesting as our method, though motivated differently, bears some notable similarities. Specifically, all three methods are gradient-based and use an extra set of parameters (architecture parameters in DARTS and SNAS) to perform some kind of soft selection (over operations/paths in DARTS/SNAS; over templates in our method). As Section 9.2 will show, our learned template coefficients $\alpha$ can often be used to fold our networks into an explicitly recurrent form - a discovered CNN-RNN hybrid.

To the extent that our method can be interpreted as a form of architecture search, it might be complementary to standard NAS methods. While NAS methods typically search over operations (e.g. activation functions; $3\times 3$ or $5\times 5$ convolutions; non-separable, separable, or grouped filters; dilation; pooling), our soft parameter sharing can be seen as a search over recurrent patterns (which layer processes the output at each step). These seem like orthogonal aspects of neural architectures, both of which may be worth examining in an expanded search space. When using SGD to drive architecture search, these aspects take on distinct forms at the implementation level: soft parameter sharing across layers (our method) vs hard parameter sharing across networks (recent NAS methods).

ImageNet:

Without any change in hyperparameters, the network trained with our method outperforms the base model and also deeper models such as DenseNets (though using more parameters), and performs close to ResNet-200, a model with four times the number of layers and a similar parameter count. See Table 4.

9.2 Architecture Search

Results on CIFAR suggest that training networks with few parameter templates $k$ in our soft sharing scheme results in performance comparable to the base models, which have significantly more parameters. The lower $k$ is, the larger we should expect the layer similarities to be: in the extreme case where $k=1$, all layers in a sharing scheme have similarity $1$, and can be folded into a single layer with a self-loop.

For the case $k>1$, there is no trivial way to fold the network, as layer similarities depend on the learned coefficients. We can inspect the model’s layer similarity matrix (LSM) and see if it presents implicit recurrences: a form of recurrence in the rows/columns of the LSM. Surprisingly, we observe that rich structures emerge naturally in networks trained with soft parameter sharing, even without the recurrence regularizer.

Figure 5 shows the per-stage LSM for CIFAR-trained SWRN 28-10-4. Here, the six layers of its stage-2 block can be folded into a loop of two layers, leading to an error increase of only $0.02\%$:

• •

(Left) Illustration of the stages of a SWRN-28-10-4 (residual connections omitted for clarity). The first two layers contain individual parameter sets, while the other six share four templates. All 3 stages of the network follow this structure.

• •

(Middle) LSM for each stage after training on CIFAR-10, with many elements close to $1$. Hard sharing schemes can be created for pairs with large similarity by tying their coefficients (or, equivalently, their effective weights).

• •

(Right) Folding stages 2 and 3 leads to self-loops and a CNN with backward connections – LSM for stage 2 is a repetition of 2 rows/columns, and folding decreases the number of parameters.

Figure 6 shows a SWRN 40-8-8 (8 parameter templates shared among groups of $\frac{40-10}{3}=10$ layers) trained with soft parameter sharing on CIFAR-10. Each stage (originally with 12 layers – the first two do not participate in parameter sharing) can be folded to yield blocks with complex recurrences. For clarity, we use colors to indicate the computational flow: red takes precedence over green, which in turn has precedence over blue. Colored paths are only taken once per stage.

Although not trivial to see, recurrences in each stage’s folded form are determined by row/column repetitions in the respective Layer Similarity Matrix. For example, for stage 2 we have $S_{5,3}\approx S_{6,4}\approx 1$, meaning that layers 3, 4, 5 and 6 can be folded into layers 3 and 4 with a loop (captured by the red edge). The same holds for $S_{7,1}$, $S_{8,2}$, $S_{9,3}$ and $S_{10,4}$, hence after the loop with layers 3 and 4, the flow returns to layer 1 and goes all the way to layer 4, which generates the stage’s output. Even though there is an approximation when folding the network (in this example, we are tying layers with similarity close to $0.8$), the impact on the test error is less than $0.3\%$. Also note that the folded model has a total of 24 layers (20 in the stage diagrams, plus 4 which are not shown, corresponding to the first layer of the network and three $1\times 1$ convolutions in skip-connections), instead of the original 40.

Finally, Figure 7 shows the same SWRN 40-8-8 more aggressively folded, where a lower threshold for the required coefficient similarity results in two fewer layers. Residual connections are omitted for simplicity, and layers are colored the same if their coefficients are sufficiently similar for them to be approximated as a single layer. Grey is used to depict layers with independent weights, which either didn’t participate in parameter sharing (the first two layers of each stage) or that didn’t present sufficient similarity to any other layer in order to be folded. Excluding the first convolution and the shortcut connections, the final folded network has a total of 18 layers, compared to 36 of the original network.

9.3 Algorithmic Task

While the propensity of our parameter sharing scheme to encourage learning of recurrent networks is a useful parameter reduction tool, we would also like to leverage it for qualitative advantages over standard CNNs. On tasks for which a natural recurrent algorithm exists, does training CNNs with soft parameter sharing lead to better extrapolation?

We train a CNN, a CNN with soft parameter sharing and one template per layer (SCNN), and an SCNN with recurrence regularizer $\lambda_{R}=0.01$. Each model trains for 50 epochs per phase with Adam (Kingma and Ba, 2015) and a fixed learning rate of $0.01$. As classes are heavily unbalanced and the balance itself changes during phases, we compare $F_{1}$ scores instead of classification error.

Each model starts with a $1\times 1$ convolution, mapping the 2 input channels to 32 output channels. Next, there are 20 channel-preserving $3\times 3$ convolutions, followed by a final $1\times 1$ convolution that maps 32 channels to 1. Each of the 20 $3\times 3$ convolutions is followed by batch normalization (Ioffe and Szegedy, 2015), a ReLU non-linearity (Nair and Hinton, 2010), and has a 1-skip connection.

Figure 8 shows one example from our generated dataset: blue pixels indicate the query points; red pixels represent obstacles, and white pixels are points in a shortest path (in terms of Manhattan distance) between query pixels. The task consists of predicting the white pixels (shortest paths) from the blue and red ones (queries and obstacles).

Figure 9 shows training curves for the 3 trained models: the SCNN not only outperforms the CNN, but adapts better to harder examples at new curriculum phases. The SCNN is also advantaged over a more RNN-like model: with the recurrence regularizer $\lambda_{R}=0.01$, all entries in the LSM quickly converge $1$, as in a RNN. This leads to faster learning during the first phase, but presents issues in adapting to difficulty changes in latter phases.

10 Experimental Analysis

Figure 10 shows LSMs of a SWRN 40-8-8 (composed of 3 stages, each with 10 layers sharing 8 templates) trained on CIFAR-10 for 5 runs with different random seeds. Although the LSMs differ across different runs, hard parameter sharing can be observed in all cases (off-diagonal elements close to 1, depicted by white), characterizing implicit recurrences which would enable network folding. Moreover, the underlying structure is similar across runs, with hard sharing typically happening among layers $i$ and $i+2$, leading to a “chessboard” pattern.

Figure 11 shows LSMs of a SWRN 40-8-8 (composed of 3 stages, each with 10 layers sharing 8 templates) at different epochs during training on CIFAR-10. The transition from an identity matrix to the final LSM happens mostly in the beginning of training: at epoch 50, the LSM is almost indistinguishable from the final LSM at epoch 200, and most of the final patterns are observable already at epoch 25.

Figure 12 shows the LSM evolution of a 100-layer CNN trained on our synthetic task. Note that, after training, a large group of layers have become functionally similar (white rectangular blocks in the LMS), while most of the remaining ones form a second group. Therefore, the network can be folded to compute long loops involving a single layer, where a secondary layer is employed between these loop calls.

11 Discussion

In this chapter, we presented a novel approach to neural architecture search based on soft parameter sharing, transforming a combinatorial NAS problem into one that is more tractable for gradient-based optimization. This work contributes to the broader goal of designing efficient deep learning systems by reducing both inference and training costs without sacrificing performance.

11.1 Contributions

This chapter makes several key contributions:

• •

We introduce a new search space for NAS which enables architectures to have backward connections, or, equivalently, reuse layer configurations across the network. This effectively decouples the network’s depth and its parameter count, makes recurrence patterns learnable, and allows for feedforward-recurrent hybrids to emerge.

• •

We propose a continuous approximation for NAS under our search space, enabling the use of gradient-based methods to optimize the network’s topology and weights jointly. Additionally, we show that the architectural coefficients can be transformed along with the weight templates to reduce rounding errors when discretizing the learned soft parameter sharing scheme.

• •

Our strategy is capable of drastically reducing the parameter count of residual networks trained on CIFAR while preserving or even improving performance. Our soft parameter sharing scheme also improves classification accuracy on ImageNet, and boosts both generalization and learning speed on algorithmic tasks.

11.2 Research Directions

Several promising research directions emerge from our work. While we focus on CNNs trained on computer vision tasks, our methodology might be extended to other model families and domains, such as RNNs and Transformers for natural language processing, or policy networks for reinforcement learning. Additionally, adopting more complex mappings from templates to effective weights, akin to employing deeper hypernetworks, could lead to further parameter reductions by reducing the dimensionality of the weight templates (something that our adopted mapping does not allow). Finally, there is significant potential in designing dynamic search spaces that evolve during training, allowing architectures to more easily learn nested loops and multi-level recurrences.

11.3 Impact

Since its introduction, our soft parameter sharing approach has inspired several follow-up studies. Researchers have extended the framework to cover a broader range of architectural components, achieving improvements in both training speed and inference efficiency (Kang and Kim, 2021; Von Oswald et al., 2021; Teterwak et al., 2024; Shin et al., 2024; Pham et al., 2024; Oh et al., 2019; Wang et al., 2020). Others have generalized architecture search under our search space (Plummer et al., 2022), and applied our methodology to other problems such as meta-learning (Zhao et al., 2020). Collectively, these efforts underscore the practical relevance of our approach and its potential to influence the design of more efficient deep learning systems.

Chapter 4 Sparsification

12 Introduction

12.1 Motivation & Strategy

In the previous chapter, we addressed efficiency by automating the design of neural architectures via NAS. In this chapter, we tackle efficiency from a different perspective: instead of searching for efficient architectures, we improve a model’s efficiency by removing unnecessary or redundant modules.

This strategy – commonly referred to as pruning or sparsification – aims to remove parameters from a pre-trained model without compromising its performance. By reducing the number of parameters, sparsification directly decreases both inference time and memory usage. Although sparsification is typically performed after training, it can also be applied gradually during training to reduce training time costs as well. Similar to NAS, sparsification involves a combinatorial optimization problem, as one must select which parameters to eliminate – a process that is computationally hard. We review previous efforts to approximate network sparsification in Section 12.2.

The remainder of the chapter is organized as follows. In Section 13.1, we formally state the sparsification problem formally and discuss its computational challenges and impact on model efficiency. Next, in Section 13.2, we re-frame the original problem multiple times to arrive at a form that can be easily approximated. Section 13.3 presents our approximation of the underlying sparsification problem, which is the core component of our novel sparsification method. Section 13.4 introduces our final algorithm and describes how it can be used to perform ticket search. The subsequent sections outline our experimental setup, report empirical result, and provide a detailed analysis of our approach, including a discussion of its contributions and impacts.

12.2 Related Work

Sparsification.

Numerous approaches have been proposed to reduce the number of parameters in deep networks without sacrificing performance. Early methods rely on heuristics to identify and remove unimportant weights from a fully-trained model (Le Cun et al., 1989). These methods use a statistic, such as the magnitude of each weight, as a proxy for its importance, and then prune the weights deemed to have the least impact on the model performance (Han et al., 2015). This two-phase process, where a model is first trained then pruned, can be repeated iteratively to further enhance sparsity and compression (Gale et al., 2019; Zhu and Gupta, 2017).

An alternative to heuristic-based pruning is to directly incorporate $\ell_{0}$ regularization into the training process. Several works propose stochastic approximations that learn a parametric distribution over binary masks, optimized jointly with the network’s weights (Srinivas et al., 2016; Louizos et al., 2018). Gradients for the distribution’s parameters are typically estimated via the straight-through estimator (Bengio et al., 2013b), although this introduces additional variance.

While heuristic methods depend critically on having a well-trained model prior to pruning, approaches that approximate $\ell_{0}$ regularization enable dynamic sparsification even during early training epochs. However, these methods can be challenging when, at aggressive sparsity levels, weights are updated infrequently, requiring longer training times.

Ticket Search.

Pruning a fully trained network often yields a sparse model that, when retrained from scratch, fails to recover the performance of the original dense network. However, Frankle and Carbin (2019) revealed that, if reinitialized with the same random seed as the original network, these sparse subnetworks can be trained to match or even exceed the dense model’s performance.

To find these subnetworks – called winning tickets – Frankle and Carbin (2019) propose Iterative Magnitude Pruning (IMP), which alternates between training, magnitude pruning, and rewinding the remaining weights to their initial values (or an early state). This procedure, known as ticket search, has gathered significant attention not only because it reveals the presence of highly efficient subnetworks, but also because winning tickets can often be transferred across tasks and training pipelines (Mehta, 2019; Soelen and Sheppard, 2019; Morcos et al., 2019). A variant of this task – non-retroactive ticket search, where the weights remain fixed at initialization while the pruning mask is optimized – has also been explored by Zhou et al. (2019a).

Despite its potential, the standard ticket search method, IMP, is computationally expensive due to the need for multiple rounds of training and pruning, motivating the search for more efficient sparsification strategies.

13 Method

13.1 Formalizing the Sparsification Problem

The sparsification problem we address consists of removing redundant or unimportant parameters from a neural network in order to reduce resource requirements – such as inference time and memory cost – while preserving performance. As in the previous chapter, we assume the dataset $D$ is chosen a-priori and remains fixed, which contains samples (and, when applicable, labels), although our approach is independent of the nature of task.

Let $f:\theta\mapsto f(\theta)$ denote a neural architecture with an associated weight space $\Theta\subseteq\mathbb{R}^{d}$, where any $\theta\in\Theta$ equips $f$ to produce a network $f(\theta)$: a function mapping samples from $D$ to outputs consistent with the underlying task. Furthermore, define the loss $\mathcal{L}:f(\theta)\mapsto\mathcal{L}(f(\theta))\in\mathbb{R}$ which evaluates the performance of a network $f(\theta)$ on the fixed dataset $D$.

Given a network architecture $f$, our goal in sparsification is to find a weight configuration $\theta\in\Theta$ that has as few nonzero components as possible, while ensuring that the induced network $f(\theta)$ performs comparably to the original dense model.

Unlike many pruning approaches that use heuristics to select weights based on proxies of importance (Han et al., 2015; Zhu and Gupta, 2017; Wortsman et al., 2019), our method relies on approximating the formal sparsification objective. This approach establishes a clear trade-off between sparsity and performance, thus eliminating the need for ad-hoc criteria to determine when and which weights to remove.

Definition 4.1** (Sparsification Problem).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, the sparsification problem is:

[TABLE]

where $\lambda\geq 0$ controls the trade-off between model performance and sparsity, and the $\ell_{0}$ pseudonorm is given by

[TABLE]

The $\ell_{0}$ pseudonorm counts the number of nonzero parameters, effectively turning the problem into a discrete selection task over which weights to zero-out. This leads to $2^{d}$ possible subsets, rendering the problem inherently combinatorial and intractable for most networks.

Although the $\ell_{0}$ regularizer is differentiable almost everywhere, its derivative is zero at any nonzero weight. In practice, unless a weight is exactly zero (which is unlikely if weights are randomly initialized), the gradient contribution from the $\ell_{0}$ term is zero. Consequently, during gradient-based training, the regularizer does not contribute to the update, effectively causing the optimization method to ignore the regularizer completely.

Structured Sparsification.

In practice, removing individual weights, known as unstructured sparsification, may reduce memory usage, but most hardware (e.g., GPUs) cannot effectively leverage irregular sparsity patterns for speed gains. In contrast, structured sparsification enforces sparsity under specific structural constraints – for example, by removing entire neurons from fully-connected layers or whole output channels from convolutional layers. This structured approach effectively reduces layer width and enables practical speedups on conventional hardware.

The structured sparsification problem can be formulated as in Definition 4.1, but with a modified $\ell_{0}$ pseudonorm that reflects the desired structure. For example, consider an $L$-layer fully-connected network with parameters $\theta=(W^{(l)})_{l=1}^{L}$, where $W^{(l)}\in\mathbb{R}^{d_{l}\times d_{l-1}}$. To remove the $i$-th neuron of layer $l$, we set all its incoming weights (i.e., the $i$-th row of $W^{(l)}$, $W^{(l)}_{i}$) to zero. In this setting, defining the $\ell_{0}$ pseudonorm as

[TABLE]

enforces the removal of entire neurons (or channels) rather than individual weights. Regardless of the imposed structure, the problem remains combinatorial and is typically intractable for large models.

13.2 Re-framing the Sparsification Problem

In this Section, we reformulate the sparsification problem in three progressive steps to arrive at a form that is amenable to the approximation we will employ.

First, we decouple the selection of weights from their values by introducing binary mask $m\in\{0,1\}^{d}$. Instead of characterizing the removal of the $i$-th component of $\theta$ by setting $\theta_{i}=0$, we now indicate weight removal by $m_{i}=0$, regardless of $\theta_{i}$. The effective weights are given by the element-wise product

[TABLE]

so that the number of retained weights is $\sum_{i=1}^{d}m_{i}$. Since $m$ is binary, we can express this sum as $\|m\|_{p}^{p}=\sum_{i=1}^{d}m_{i}^{p}$ for any $p>0$. This reformulation leads to the following equivalent problem:

Definition 4.2** (Re-framed Sparsification Problem (Version 1)).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, for any $p>0$, the sparsification problem can be rewritten as

[TABLE]

which is equivalent to the problem in Definition 4.1.

This version highlights the combinatorial nature of the problem, now condensed in the discrete domain of $m$.

Next, we reparameterize the binary mask $m$ by expressing it as the output of a surjective binary function $b:\mathbb{R}\to\{0,1\}$. Specifically, we define $m=b(s)$, where $b$ is applied element-wise and $s\in\mathbb{R}^{d}$ becomes the new optimization variable. This changes the problem to one of optimizing over continuous variables $s$ instead of binary $m$:

Definition 4.3** (Re-framed Sparsification Problem (Version 2)).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$ and let $b:\mathbb{R}\to\{0,1\}$ be a surjective binary function applied element-wise. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, for any $p>0$, the sparsification problem can be rewritten as

[TABLE]

which is equivalent to the problem in Definition 4.1.

Although the optimization variables are now continuous, the function $b$ (e.g., step function) remains discontinuous with zero derivative almost everywhere, posing the same challenges as the original $\ell_{0}$ regularizer.

To address this, we replace $b$ with a family of smooth functions that converge point-wise to $b$. Let $\hat{b}:\mathbb{R}\times\mathbb{R}\to\mathbb{R}$ be such that, for all $s\in\mathbb{R}$,

[TABLE]

hence for any continuous function $g$,

[TABLE]

Then, the final re-formulation is:

Definition 4.4** (Re-framed Sparsification Problem (Version 3)).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Moreover, let $\hat{b}:\mathbb{R}\times\mathbb{R}\to\mathbb{R}$ satisfy

[TABLE]

where $b:\mathbb{R}\to\{0,1\}$ is surjective. Then, if $\mathcal{L}\circ f$ is continuous, for any $p>0$ the sparsification problem can be rewritten as

[TABLE]

which is equivalent to the problem in Definition 4.1.

At first glance, this formulation may not seem advantageous. However, note that $\hat{b}(\beta,\cdot)$ is allowed to be smooth for any finite $\beta$, thus being amenable to gradient-based optimization. The inherent difficulty of the original problem is then encapsulated in the limit $\beta\to\infty$.

13.3 Approximating the Sparsification Problem

In Version 3 of our re-framed sparsification problem (Definition 4.4), the objective involves taking the limit $\beta\to\infty$ to recover the binary mask $b$ from its smooth approximation $\hat{b}(\beta,\cdot)$. Our approximation consists of swapping the order of the minimization and the limit:

Definition 4.5** (Approximate Sparsification Problem).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Moreover, let $\hat{b}:\mathbb{R}\times\mathbb{R}\to\mathbb{R}$ be a smooth function that satisfies

[TABLE]

where $b:\mathbb{R}\to\{0,1\}$ is surjective. Then, if $\mathcal{L}\circ f$ is continuous, for any $p>0$, the approximate sparsification problem is

[TABLE]

In this setting, the objective of the minimization problem,

[TABLE]

is continuous and amenable to gradient-based optimization since $\hat{b}(\beta,\cdot)$ is smooth for any finite $\beta$. In practice, we iteratively update $\theta$ and $s$ to minimize $\mathcal{L}_{\beta}(\theta,s)$ while gradually annealing $\beta$ during training. Note that increasing $\beta$ makes the problem progressively harder, as $\hat{b}(\beta,\cdot)$ becomes sharper and $\mathcal{L}_{\beta}$ less smooth in the optimization sense.

There are two sources of error in our approximation. First, by swapping the minimization and the limit, we do not generally obtain an equivalent problem. In fact, for a sequence of real-valued functions $(g_{n})_{n\in\mathbb{N}}$ defined on a set $X$ that converges point-wise to $g$, we have

[TABLE]

Thus, our approximation effectively optimizes a lower bound of the original problem. In the framework of continuation methods, we typically consider additional assumptions – such as $\Gamma$-convergence and equi-coercivity of the family $(\mathcal{L}_{\beta})_{\beta}$ – to ensure that there is no gap in the limit.

Second, as $\beta$ increases during training, the soft mask $\hat{b}(\beta,\cdot)$ necessarily becomes increasingly sharp. Consequently, $\mathcal{L}_{\beta}$ becomes less smooth and requires more training iterations to be effectively minimized. In practice, however, we do not increase the number of training iterations as $\beta$ grows in order to keep the method fast and efficient.

13.4 The Proposed Sparsification Method

For our method, we instantiate the binary function $b$ as the Heaviside step function $b(s)=H(s)=\mathbbm{1}\{s\geq 0\}$ and approximate it using the sigmoid function. Specifically, we define

[TABLE]

We also set the norm parameter $p=1$ so that the sparsity regularizer is simply $\|\hat{b}(\beta,s)\|_{1}=\|\sigma(\beta s)\|_{1}$. In terms of sparsification, every negative component of $s$ will drive the corresponding element of the effective weight $\theta\odot\sigma(\beta s)$ towards zero as $\beta$ increases. Although analytically $\sigma(\beta s)$ is never exactly zero for any finite $\beta$, limited numerical precision ensures that, beyond a certain threshold, the weights are effectively pruned during training.

Our overall approach consists of jointly optimizing the network weights $\theta$ and the mask parameters $s$ to minimize $\mathcal{L}_{\beta}$ using gradient descent. We anneal $\beta$ during training following an exponential schedule defined by $\beta$ starting as $1$ and ending with a pre-determined value $\beta_{final}$ after $T$ time steps, which amounts to scaling $\beta$ by $\beta_{final}^{1/T}$ at the end of each iteration. This schedule allows the mask $\sigma(\beta s)$ to transform from smooth values to an approximation of a binary mask as training progresses. At the end of training, when $\beta$ is sufficiently large, we can either use the learned mask $\sigma(\beta s)$ directly (which, due to numerical precision, may be mostly binary), or explicitly round it to obtain a binary mask $m=H(s)$.

Our final method, Continuous Sparsification (CS), is given in Algorithm 1. Although we included an optional fine-tuning step for the weights, our empirical results indicate that this step is typically unnecessary when $\beta_{final}$ is large (e.g., around 500 or above).

Note that many alternative choices for the smooth function $\hat{b}(\beta,\cdot)$ are valid. In particular, any sigmoidal function may be used in place of $\sigma$. Although we have not explored these alternatives in our experiments, investigating different forms for $\hat{b}$ could potentially lead to performance improvements. For example:

• •

$\hat{b}(\beta,s)=\frac{1}{2}(1+\operatorname{erf}(\beta s))$

• •

$\hat{b}(\beta,s)=\frac{1}{2}\left(1+\frac{s}{\left(\beta^{-1}+|s|^{k}\right)^{\frac{1}{k}}}\right)$ for any $k>0$

• •

$\hat{b}(\beta,s)=\frac{1}{2}\left(1+\frac{\pi}{2}\arctan(\beta s)\right)$

Ticket Search.

Ticket search is the task of identifying sparse subnetworks (winning tickets) that can be trained from scratch to achieve performance comparable to that of the full, overparameterized model. Discovering such subnetworks not only challenges the conventional belief that overparameterization is essential for state-of-the-art performance, but also offers the potential to drastically reduce computational and memory requirements during both training and inference. This reduction in resource costs can enable more efficient deployment on hardware-constrained devices and lower the overall energy footprint of deep learning systems.

To design a ticket search strategy from our sparsification method, we follow Iterative Magnitude Pruning (IMP) (Frankle and Carbin, 2019) and operate in rounds. At the start of each round, we reset $\beta$ to 1 to allow further sparsification, and then gradually increase $\beta$ again as the round progresses. Additionally, we reset the soft mask parameters $s$ for weights that have not been suppressed, ensuring that the pruning process remains dynamic. Specifically, we set $s\leftarrow\min(\beta\cdot s,s_{init})$ when starting a new round. Algorithm 2 presents our method for ticket search, which, in contrast to IMP, does not rewind weights between rounds.

In our experiments, we compare Continuous Sparsification method with IMP, the algorithm used in Frankle and Carbin (2019) to find winning tickets. At each round, IMP removes a fixed percentage of weights with the smallest magnitudes by setting their corresponding mask entries to zero, followed by rewinding the remaining weights to an earlier state (Algorithm 3). While IMP has been shown successful when performing ticket search, its reliance on heuristic, magnitude-based pruning and the need for multiple rounds of training make it computationally expensive and potentially suboptimal. In contrast, our method integrates sparsification directly into the training process through a deterministic approximation of $\ell_{0}$ regularization, leading to a potentially more efficient approach for finding winning tickets.

14 Experimental Setup

14.1 Datasets

CIFAR-10.

The CIFAR-10 dataset (Krizhevsky, 2009) consists of $32\times 32$ color images split into 50,000 and 10,000 training and test samples, each belonging to one out of 10 classes. We pre-process the data by applying channel-wise normalization to all images using statistics computed from the training set. We use the standard data augmentation pipeline from He et al. (2016a), which includes random crops and horizontal flips.

ImageNet.

We employ the ILSVRC 2012 subset of ImageNet (Russakovsky et al., 2015), which contains roughly 1.28 million training images and 50,000 validation images belonging to 1,000 different object classes. We use single $224\times 224$ center-crop images for both training and validation. We follow Gross and Wilber (2016) for pre-processing and data augmentation, which consists of scale augmentation (random crops of different sizes and aspect ratios are rescaled back to the original size with bicubic interpolation), photometric distortions (random changes to brightness, contrast, and saturation), lighting noise, and horizontal flips. Channel-wise normalization is employed using statistics from a random subset of the training data.

14.2 Models

VGG-16.

For CIFAR-10, we adopt a variant of VGG-16, a deep network characterized by a uniform CNN architecture built from multiple convolutional and pooling layers and followed by fully connected layers. In our implementation, the convolutions are followed by ReLU and batch normalization, which helps stabilize training and improve convergence. The relatively straightforward and homogeneous design of VGG-16 makes it an excellent candidate for analyzing the effects of sparsification, as any removal of parameters can be directly related to changes in performance.

ResNet-20.

Also for CIFAR-10, we employ ResNet-20—a residual network that incorporates skip connections to facilitate the training of deeper architectures. ResNet-20 is constructed from a series of residual blocks, each comprising two convolutions with batch normalization and ReLU activations. This architecture serves as a representative residual model to evaluate how sparsification impacts both parameter reduction and performance in more modern networks.

ResNet-50.

For experiments on ImageNet, we use ResNet-50, a widely adopted benchmark architecture that achieves a strong balance between depth, computational efficiency, and performance. ResNet-50 is built from bottleneck residual blocks – each block consists of a $1\times 1$ depth-reducing convolution, a $3\times 3$ dept-preserving convolution, and a $1\times 1$ depth-increasing convolution, each followed by batch normalization and ReLU activations. Our ResNet-50 experiments are designed to test the scalability of sparsification methods to large-scale networks and complex datasets.

6-layer CNN for Supermask Search.

In addition to the above models, we include a small 6-layer CNN for supermask search experiments on CIFAR-10. This network is constructed with three blocks, each containing two resolution-preserving $3\times 3$ convolutional layers followed by $2\times 2$ max-pooling. The number of channels increases across the blocks (64, 128, and 256 channels), and the convolutional layers are immediately followed by ReLU activations. The network concludes with a series of fully connected layers (256, 256, and 10 neurons). The simplicity of this architecture allows us to isolate the effects of learning binary masks on randomly initialized weights, providing valuable insights into the supermask formulation without the added complexity of deeper networks.

14.3 Training

For CS, we set hyperparameters $\lambda=10^{-8}$ and $\beta_{final}=200$, based on analysis in Section 16, which studies how $\lambda$, $s_{init}$, and $\beta_{final}$ affect the sparsity of produced subnetworks. We observe that $s_{init}$ has a major impact on sparsity levels, while $\lambda$ and $\beta_{final}$ require little to no tuning.

Sparse Networks on CIFAR.

We train VGG-16 and ResNet-20 on CIFAR-10 for 200 epochs, with a initial learning rate of $0.1$ which is decayed by a factor of $10$ at epochs 80 and 120. The subnetwork is produced at epoch 160 and is then fine-tuned for 40 extra epochs with a learning rate of $0.001$. More specifically, at epoch 160 the subnetwork structured is fixed: AMC, MP, GMP and Slim zero-out elements in the binary matrix $m$ for the last time, while CS fixes $m=H(s)$ and $s$ is no longer trained.

Ticket Search on CIFAR.

We follow the setup from Frankle and Carbin (2019): in each round, we train with SGD, a learning rate of $0.1$, and a momentum of $0.9$, for a total of $85$ epochs, using a batch size of $64$ for VGG and $128$ for ResNet. We decay the learning rate by a factor of $10$ at epochs $56$ and $71$, and utilize a weight decay of $0.0001$.

For CS, we do not apply weight decay to the mask parameters $s$, since they are already suffer $\ell_{1}$ regularization. Sparsification is performed on all convolutional layers, excluding the two skip-connections of ResNet-20 that have $1\times 1$ kernels: for IMP, their parameters are not pruned, while for CS their weights do not have an associated learnable mask.

IMP performs global pruning at a per-round rate, removing $20\%$ of the remaining parameters with smallest magnitude. We run IMP for $30$ iterations, yielding $30$ tickets with varying sparsity levels ($80\%,64\%,\dots$). To produce tickets of differing sparsity with CS, we vary $s_{init}$ across $11$ values from $-0.3$ to $0.3$, performing a run of 5 rounds for each setting. We repeat experiments 3 times, with different random seeds.

ImageNet.

Following Frankle et al. (2019), we train the network with SGD for 90 epochs, with an initial learning rate of $0.1$ that is decayed by a factor of 10 at epochs $30$ and $60$. We use a batch size of 256 distributed across 4 GPUs and a weight decay of $0.0001$. We run CS for a single round due to the high computational cost of training ResNet-50 on ImageNet, with $s_{init}\in\{0.0,-0.01,-0.02,-0.03,-0.05\}$ yielding 5 subnetworks with varying sparsity levels.

Supermask Search and Ticket Search on 6-layer CNN.

All parameters are trained using Adam and a learning rate of $3\times 10^{-4}$, excluding the mask parameters $s$ for Stochastic Sparsification, for which we adopted SGD with a learning rate of $100$ following Zhou et al. (2019a), and for Iterative Stochastic Sparsification, where $s$ is trained with SGD and a learning rate of $20$.

14.4 Evaluation

Test Accuracy and Top-1/Top-5 Accuracy.

For the CIFAR datasets, we measure and report the accuracy on the 10,000 test samples. On ImageNet, we use the top-1 and top-5 accuracy on the 50,000 validation images. Top-5 accuracy is the fraction of samples for which the true label appears among the top five predicted classes.

Sparsity.

We compare methods on the tasks of pruning and finding matching subnetworks. We quantify the performance of ticket search by focusing on two specific subnetworks produced by each method:

• •

Sparsest matching subnetwork: the sparsest subnetwork that, when trained in isolation from an early iterate, yields performance no worse than that achieved by the trained dense counterpart.

• •

Best performing subnetwork: the subnetwork that achieves the best performance when trained in isolation from an early iterate, regardless of its sparsity.

We also measure the efficiency of each method in terms of total number of epochs to produce subnetworks, given enough parallel computing resources. As we will see, CS is particularly suited for parallel execution since it requires relatively few rounds to produce subnetworks regardless of sparsity. On the other hand, CS offers no explicit mechanism to control the sparsity of the found subnetworks, hence producing a subnetwork with a pre-defined sparsity level can require multiple runs with different hyperparameter settings. For this use case, IMP is more efficient by design, since a single run suffices to produce subnetworks with varying, pre-defined sparsity levels.

15 Results

15.1 Sparsification on CIFAR

First, we evaluate CS as a general-purpose sparsification method. We compare it against the prominent pruning methods AMC He et al. (2018), magnitude pruning (MP) Han et al. (2015), GMP Zhu and Gupta (2017), and Network Slimming (Slim) Liu et al. (2017), along with the $\ell_{0}$-based method of Louizos et al. (2018) (referred to as “$\ell_{0}$”), which, in contrast to ours, adopts a stochastic approximation for $\ell_{0}$ regularization.

Adopting the inference behavior suggested in Louizos et al. (2018) for $\ell_{0}$, i.e., using the expected value of the uniform distribution to generate hard concrete samples, leads to poor results, including accuracy akin to random guessing at sparsity above $90\%$; this is also reported by Gale et al. (2019). Instead, at epoch 160, we sample different masks and commit to the one that performs the best – this strategy results in drastic improvements at high sparsity levels. This suggests that the gap between training and inference behavior introduced by stochastic approaches can be an obstacle. Although our modification improves results for $\ell_{0}$, the method still performs poorly compared to alternatives.

Moreover, some methods required modifications as they were originally designed to perform structured pruning. For AMC, Slim, and $\ell_{0}$ we replace a filter-wise mask by one that acts over weights. Since Network Slimming relies on the filter-wise scaling factors of batch norm, we introduce weight-wise scaling factors which are trained jointly with the weights. We observe that applying both $\ell_{1}$ and $\ell_{2}$ regularization to the scaling parameters, as done by Liu et al. (2017), yields inferior performance, which we attribute to over-regularization. A grid search over the penalty of each norm regularizer shows that only applying $\ell_{1}$ regularization with a strength of $\lambda_{1}=10^{-5}$ for ResNet-20 and $\lambda_{1}=10^{-6}$ for VGG-16 improves results.

Figures 13 and 14 display one-shot pruning results. On VGG, only CS and Slim successfully prune over $98\%$ of the weights without severely degrading the performance of the model, while on ResNet the best results are achieved by CS and GMP.

Table 5 shows the percentage of weights that each method can remove while maintaining a performance within $2\%$ of the original, dense model. CS is capable of removing significantly more parameters than all competing methods on both networks: on ResNet-20, the pruned network found by CS contains $60\%$ less parameters than the one found by GMP, when counting prunable parameters only. CS not only offers significantly superior performance compared to the prior $\ell_{0}$-based method of Louizos et al. (2018), but also comfortably outperforms all other methods, providing a new state-of-the-art for network pruning.

15.2 Finding Winning Tickets

Next, we evaluate how IMP and CS perform on the task of ticket search for VGG-16 (Simonyan and Zisserman, 2015) and ResNet-20111We used the same network as Frankle and Carbin (2019) and Frankle et al. (2019), who refer to it as ResNet-18. (He et al., 2016a) trained on the CIFAR-10 dataset, a setting where IMP can take over $10$ rounds (850 epochs given 85 epochs per round (Frankle et al., 2019)) to find sparse subnetworks. We evaluate produced subnetworks by initializing their weights with the iterates from the end of epoch 2, similarly to Frankle et al. (2019), followed by re-training.

Figures 15 and 16 show the performance and sparsity of tickets produced by CS and IMP, including IMP without rewinding (continued). Purple curves show individual runs of CS for different values of $s_{init}$, each consisting of 5 rounds, and the green curve shows the performance of subnetworks produced with different hyperparameters. Plots of individual runs are available in Section 16, but have been omitted here for the sake of clarity. Given a search budget of 5 rounds (i.e., $5\times 85=425$ epochs), CS successfully finds subnetworks with diverse sparsity levels. Notably, IMP produces tickets with superior performance when weight rewinding is not employed between rounds.

Table 6 summarizes the performance of each method when evaluated in terms of the sparsest matching and best performing subnetworks. IMP-C denotes IMP without rewinding, i.e., IMP (continued) from Figures 15 and 16. Sparsest matching subnetworks produced by CS are sparser than the ones found by IMP and IMP-C, while also delivering higher accuracy. CS also outperforms IMP and IMP-C when evaluating the best performing produced subnetworks. In particular, CS yields highly sparse subnetworks that outperform the original model by approximately $1\%$ on both VGG-16 and ResNet-20.

If all runs are executed in parallel, producing all tickets presented in Figure 14 takes CS a total of $5\times 85=425$ training epochs, while IMP requires $30\times 85=2550$ epochs instead. Note that our re-parameterization results in approximately $10\%$ longer training times on a GPU due to the mask parameters $s$, therefore wall-clock time for CS is $10\%$ higher per epoch. Sequential search takes $5\times 11\times 85=4675$ epochs for CS to produce all tickets, while IMP requires $30\times 85=2550$ epochs, hence CS is faster given sufficient parallelism, but slower if run sequentially. Section 16 shows preliminary results of a variant of CS designed for sequential search.

15.3 Residual Networks on ImageNet

We perform pruning and ticket search for ResNet-50 trained on ImageNet Russakovsky et al. (2015). Once the round is complete, we evaluate the performance of the produced subnetwork when fine-tuned (pruning) or re-trained from an early iterate (ticket search).

Table 7 summarizes the results achieved by CS, IMP, and current state-of-the-art pruning methods GMP Zhu and Gupta (2017), STR Kusupati et al. (2020), and DNW Wortsman et al. (2019). A † superscript denotes results of a re-trained, rather than fine-tuned, subnetwork. Differences in each technique’s methodology – for example, the adopted learning rate schedule and number of epochs – complicate the comparison.

CS produces subnetworks that, when re-trained, outperform the ones found by IMP by a comfortable margin (compare CS† and IMP†). Moreover, when evaluated as a pruning method, CS outperforms all competing approaches, especially in the high-sparsity regime. Therefore, our method provides state-of-the-art results whether the network is fine-tuned (pruning) or re-trained (ticket search).

[TABLE]

16 Experimental Analysis

16.1 Hyperparameter Analysis

Continuous Sparsification.

In this section, we study how the hyperparameters of CS affect its behavior in terms of sparsity and performance of the produced tickets. More specifically, we consider the following hyperparameters:

• •

Final temperature $\beta_{final}$: the final value for $\beta$, which controls how close to the original $\ell_{0}$-regularized problem the proxy objective $L_{\beta}(w,s)$ is.

• •

$\ell_{1}$ penalty $\lambda$: the strength of the $\ell_{1}$ regularization applied to the soft mask $\sigma(\beta s)$, which promotes sparsity.

• •

Mask initial value $s_{init}$: the value used to initialize all components of the soft mask $m=\sigma(\beta s)$, where smaller values promote sparsity.

Our setup is as follows. To analyze how each of the 3 hyperparameters impact the performance of Continuous Sparsification, we train ResNet-20 on CIFAR-10, varying one hyperparameter while keeping the other two fixed. To capture how hyperparameters interact with each other, we repeat the described experiment with different settings for the fixed hyperparameters.

Since different hyperparameter settings naturally yield vastly distinct sparsity and performance for the found tickets, we report relative changes in accuracy and in sparsity.

In Figure 17, we vary $\lambda$ between [math] and $10^{-8}$ for three different $(s_{init},\beta_{final})$ settings: $(s_{init}=-0.2,\beta_{final}=100)$, $(s_{init}=0.05,\beta_{final}=200)$, and $(s_{init}=-0.3,\beta_{final}=100)$. As we can see, there is little impact on either the performance or the sparsity of the found ticket, except for the case where $s_{init}=0.05$ and $\beta_{final}=200$, for which $\lambda=10^{-8}$ yields slightly increased sparsity.

Next, we consider the fixed settings $(s_{init}=-0.2,\lambda=10^{-10})$, $(s_{init}=0.05,\lambda=10^{-12})$, $(s_{init}=-0.3,\lambda=10^{-8})$, and proceed to vary the final inverse temperature $\beta_{final}$ between 50 and 200. Figure 18 shows the results: in all cases, a larger $\beta$ of $200$ yields better accuracy. However, it decreases sparsity compared to smaller temperature values for the settings $(s_{init}=-0.2,\lambda=10^{-10})$ and $(s_{init}=-0.3,\lambda=10^{-8})$, while at the same time increasing sparsity for $(s_{init}=0.05,\lambda=10^{-12})$. While larger $\beta$ appear beneficial and might suggest that even higher values should be used, note that, the larger $\beta_{final}$ is, the earlier in training the gradients of $s$ will vanish, at which point training of the mask will stop. Since the performance for temperatures between 100 and 200 does not change significantly, we recommend values around 150 or 200 when either pruning or performing ticket search.

Lastly, we vary the initial mask value $s_{init}$ between $-0.3$ and $+0.3$, with hyperpameter settings $(\beta_{final}=100,\lambda=10^{-10})$, $(\beta_{final}=200,\lambda=10^{-12})$, and $(\beta_{final}=100,\lambda=10^{-8})$. Results are given in Figure 19: unlike the exploration on $\lambda$ and $\beta_{final}$, we can see that $s_{init}$ has a strong and consistent effect on the sparsity of the found tickets. For this reason, we suggest proper tuning of $s_{init}$ when the goal is to achieve a specific sparsity value. Since the percentage of remaining weights is monotonically increasing with $s_{init}$, we can employ search strategies over values for $s_{init}$ to achieve pre-defined desired sparsity levels (e.g., binary search). In terms of performance, lower values for $s_{init}$ naturally lead to performance degradation, since sparsity quickly increases as $s_{init}$ becomes more negative.

Iterative Magnitude Pruning.

Here, we assess whether the running time of Iterative Magnitude Pruning can be improved by increasing the amount of parameters pruned at each iteration. The goal of this experiment is to evaluate if better tickets (both in terms of performance and sparsity) can be produced by more aggressive pruning strategies.

Following the same setup as the previous section, we train ResNet-20 on CIFAR-10. We run IMP for 30 iterations, performing global pruning with different pruning rates at the end of each iteration. Figure 20 shows that the performance of tickets found by IMP decays when the pruning rate is increased to $40\%$. In particular, the final performance of found tickets is mostly monotonically decreasing with the number of remaining parameters, suggesting that, in order to find tickets which outperform the original network, IMP is not compatible with more aggressive pruning rates.

16.2 Iterative Stochastic Sparsification

Besides comparing our proposed method to Iterative Magnitude Pruning (Algorithm 3), we also design a baseline method, Iterative Stochastic Sparsification (ISS, Algorithm 4), motivated by the procedure in Zhou et al. (2019a) to find a binary mask $m$ with gradient descent in an end-to-end fashion. More specifically, ISS uses a stochastic re-parameterization $m\sim\text{Bernoulli}(\sigma(s))$ with $s\in\mathbb{R}^{d}$, and trains $w$ and $s$ jointly with gradient descent and the straight-through estimator (Bengio et al., 2013b). Note that the method is also similar to the one proposed by Srinivas et al. (2016) to prune networks. The goal of this baseline and comparisons is to evaluate whether the deterministic nature of CS’s re-parameterization is advantageous when performing sparsification through optimization methods.

When run for multiple iterations, all components of the mask parameters $s$ which have decreased in value from initialization are set to $-\infty$, such that the corresponding weight is permanently removed from the network. While this might look arbitrary, we observe empirically that ISS was unable to remove weights quickly without this step unless $\lambda$ is chosen to be large – in which case the model’s performance degrades due to increased sparsity.

We also observe that the mask parameters $s$ require different settings in terms of optimization to be successfully trained. In particular, Zhou et al. (2019a) use SGD with a learning rate of 100 when training $s$, which is orders of magnitude larger than the one used when training CNNs. Our observations are similar, in that typical learning rates on the order of 0.1 cause $s$ to be barely updated during training, which is likely a side-effect of using gradient estimators to obtain update directions for $s$. The following sections present experiments that compare IMP, CS and ISS on ticket search tasks.

16.3 Searching for Supermasks

We train a neural network with 6 convolutional layers on the CIFAR-10 dataset (Krizhevsky, 2009), following Frankle and Carbin (2019). As a first baseline, we consider the task of learning a “supermask” (Zhou et al., 2019a): a binary mask $m$ that aims to maximize the performance of a network with randomly initialized weights once the mask is applied. This task is equivalent to pruning a randomly-initialized network since weights are neither updated during the search for the supermask, nor for the comparison between different methods.

We only compare ISS and CS for this specific experiment: the reason not to consider IMP is that, since the network weights are kept at their initialization values, IMP amounts to removing the weights whose initialization were the smallest.

Hence, we compare ISS and CS, where each method is run for a single round composed of $100$ epochs. In this case, where it is run for a single round, ISS is equivalent to the algorithm proposed in Zhou et al. (2019a) to learn a supermask, referred here as simply Stochastic Sparsification (SS). We control the sparsity of the learned masks by varying $s_{init}$ and $\lambda$.

Figure 21 presents results: CS is capable of finding high performing sparse supermasks (i.e., $25\%$ or less remaining weights while yielding $75\%$ test accuracy), while SS fails at finding competitive supermasks for sparsity levels above $50\%$. Moreover, CS makes faster progress in training, suggesting that not relying on gradient estimators indeed results in better optimization and faster progress when measured in epochs or parameter updates.

16.4 Additional Ticket Search Experiments

6-layer CNN.

In what follows we compare IMP, ISS and CS in the task of finding winning tickets on the Conv-6 architecture used in the supermask experiments in the previous section. The goal of these experiments is to assess how our deterministic re-parameterization compares to the common stochastic approximations to $\ell_{0}$-regularization (Srinivas et al., 2016; Louizos et al., 2018; Zhou et al., 2019a). Therefore, we run CS with weight rewinding between rounds, so that we remove any advantages that might be caused by not performing weight rewinding – in this case, we better isolate the effects caused by our re-parameterization. Following Frankle and Carbin (2019), we re-train the produced tickets from their values at initialization (i.e., $k=0$ on each algorithm).

We run IMP and ISS for a total of 30 rounds, each consisting of 40 epochs. For IMP, we use pruning rates of $15\%/20\%$ for convolutional/dense layers. We initialize the Bernoulli parameters of ISS with $s_{init}=\vec{1}$ and adopt $\ell_{1}$ regularization of $\lambda=10^{-8}$. Each run of CS is limited to $4$ rounds, and we perform a total of 16 runs, each with a different value for the mask initialization $s_{init}$, from $-0.2$ up to $0.1$. Runs are repeated with 3 different random seeds so that error bars can be computed.

Figure 23 presents tickets produced by each method, measured by their sparsity and test accuracy when trained from scratch. Even when performing weight rewinding, CS produces tickets that are significantly superior than the ones found by ISS, both in terms of sparsity and test accuracy, showing that our deterministic re-parameterization is fundamental to finding winning tickets.

Learned Sparsity Structure

To see how CS differs from magnitude pruning in terms of which layers are more heavily pruned by each method, we force the two to prune VGG to the same sparsity level in a single round. We first run CS with $s_{init}=0$, yielding $94.19\%$ sparsity, and then run IMP with global pruning rate of $94.19\%$, producing a sub-network with the same number of parameters.

Figure 24 shows the final sparsity of blocks consisting of two consecutive convolutional layers (8 blocks total since VGG has 16 convolutional layers). CS applies a pruning rate that is roughly twice as aggressive as IMP to the first blocks. Both methods heavily sparsify the widest layers of VGG (blocks 5 to 8), while still achieving over $91\%$ test accuracy. More heavily pruning earlier layers in CNNs can offer inference speed benefits: due to the increased spatial size of earlier layers’ inputs, each weight is used more times and has a larger contribution in terms of FLOPs.

16.5 Sequential Search with Continuous Sparsification

There might be cases where the goal is either to find a ticket with a specific sparsity value or to produce a set of tickets with varying sparsity levels in a single run – tasks that can be naturally performed with a single run of Iterative Magnitude Pruning. However, CS has no explicit mechanism to control the sparsity of the produced tickets, and, as shown in Sections 15.2 and  16.4, CS quickly sparsifies the network in the first few rounds and then roughly maintains the number of parameters during the following rounds until the end of the run. In this scenario, IMP has a clear advantage, as a single run suffices to produce tickets with varying, pre-defined sparsity levels.

Here, we present a sequential variant of CS, named Sequential Continuous Sparsification, that removes a fixed fraction of the weights at each round, hence being better suited for the task described above. Unlike IMP, this sequential form of CS removes the weights with lowest mask values $s$ – note the difference from CS, which, given a large enough temperature $\beta$, removes all weights whose corresponding mask parameters are negative.

Following the same experimental protocol from Section 15.2, we again perform ticket search on ResNet-20 trained on CIFAR-10. We run Sequential CS and Iterative Magnitude Pruning for a total of 30 rounds each, and with a pruning rate of $20\%$ per round. Note that unlike the experiments with CS (the non-sequential form), we perform a single run with $s_{init}=0$, i.e., no hyperparameters are used to control the sparsity of the produced tickets.

Figure 25 shows the performance of tickets produced by Sequential CS and IMP, indicating that CS might be a competitive method in the sequential search setting. Note that the performance of the tickets produced by Sequential CS is considerably inferior to those found by CS (refer to Section 15.2, Figures 15 and 16). Although these results are promising, additional experiments would be required to more thoroughly evaluate the potential of Sequential CS and its comparison to Iterative Magnitude Pruning.

17 Discussion

In this chapter, we have introduced a novel sparsification method – Continuous Sparsification – that approximates the intractable $\ell_{0}$ regularization objective in a fully deterministic manner. Unlike heuristic-based pruning approaches and stochastic $\ell_{0}$ approximations, our method leverages a smooth continuation to gradually remove weights from a network. This approach not only integrates sparsification directly into the training process but also offers a formal trade-off between model performance and compression.

17.1 Contributions

This chapter makes several key contributions:

• •

We propose a new approximation for the intractable network sparsification problem. Unlike previous works, we design a fully deterministic approximation for $\ell_{0}$ regularization, which allows for gradient-based optimization without gradient estimators or additional variance.

• •

We present empirical evidence that our method is capable of achieving high sparsity levels while maintaining, and in some cases even improving, the predictive performance of dense models trained on CIFAR-10 and ImageNet.

• •

Extending our sparsification method to perform ticket search, we successfully discover winning tickets on ResNets trained on CIFAR-10 and on ImageNet at a fraction of the time taken by Iterative Magnitude Pruning.

17.2 Research Directions

One potential research direction is integrating Continuous Sparsification with architecture search methods. Combining our sparsification framework with NAS or adaptive network design could enable simultaneous optimization of both network topology and sparsity, leading to even more efficient models tailored for specific tasks or hardware constraints. Finally, further theoretical analysis of our deterministic approximation and its convergence properties may provide deeper insights into the trade-offs between sparsity and performance. Such analysis could help direct modifications to Continuous Sparsification to guarantee near-optimal sparsity configurations.

17.3 Impact

After being proposed, Continuous Sparsification has influenced subsequent works in neural network efficiency. In particular, Yuan et al. (2021) designs an algorithm that dynamically grows and shrinks networks during training, where shrinkage is achieved extending CS to structured sparsity regimes. By starting from a smaller network and continuously growing it during training, the proposed method offers training time reductions at small or no final performance degradation. Furthermore, Xiao et al. (2023) propose Continuous Sparsification Quantization, which integrates CS into a bi-level optimization framework alongside mixed-precision quantization. CSQ enhances computational efficiency on resource-constrained settings where aggressive quantization is typically required alongside sparsification. These works punctuate the adaptability of Continuous Sparsification, showing that it serves as a foundational method for network compression that can be applied not only to network sparsification, but also to growing and quantization.

Chapter 5 Quantization

18 Introduction

18.1 Motivation & Strategy

In Chapter 4, we improved model efficiency by gradually removing redundant or unimportant parameters during training: a process known as pruning or sparsification. In this chapter, we take a different approach: rather than eliminating parameters, we optimize the numerical precision at which each parameter is represented. Our goal is to minimize the total number of bits required to represent the network’s parameters while preserving its performance.

Traditional quantization-aware optimization fixes the precision beforehand. In contrast, we address a more general problem in which the precision is not predetermined but is instead treated as an optimization variable alongside each parameter’s quantized value. By doing so, we aim to achieve a heterogeneous precision assignment that can further reduce inference time and memory costs. Like NAS and network sparsification, this quantization problem is inherently combinatorial and intractable in its exact form. Previous approaches to approximate network quantization are reviewed in Section 18.2.

Section 19.1 formally states the mixed precision quantization problem and discusses its core computational challenges. Then, Section 19.2 re-frames the problem as one with infinite constraints, which can be readily approximated via stochastic methods. Section 19.3 presents our approximation strategy – the core component of our final mixed precision method. The remaining sections outline our experimental setup, report empirical results assessing our proposed method, and offer a deeper experimental analysis of our approach, including a discussion of its contributions and impacts.

18.2 Related Work

Most approaches in the quantization literature assume that a predefined precision is given prior to training (Zhou et al., 2016; Zhang et al., 2018a; Gong et al., 2019; Yang et al., 2020; Hubara et al., 2017; Miyashita et al., 2016; Choi et al., 2018; Lin et al., 2017; Han et al., 2016; Esser et al., 2020), designating the number of bits used to represent each parameter of the network. The focus of these works is typically to circumvent the obstacle posed by the non-differentiability of the quantization function, as this makes first-order methods inapt to train quantized models due to the lack of meaningful gradients.

DoReFa (Zhou et al., 2016) updates real-valued weights using gradients w.r.t. their quantized forms (i.e., a straight-through estimator (Bengio et al., 2013a)), enabling training over quantized parameter values with gradient descent. LQ-Nets (Zhang et al., 2018a), PACT (Choi et al., 2018), and LSQ (Esser et al., 2020) introduce further flexibility to quantization by also optimizing the quantization step size, which we refer by quantization scale throughout our work, i.e., the real value that each bit corresponds to is also learned.

DSQ (Gong et al., 2019) proposes a smooth approximation to the quantization mapping, which allows weights to be directly trained with SGD without straight-through estimators. SLB (Yang et al., 2020) introduces per-parameter auxiliary variables that induce distributions over values that quantized weights can take – these variables are trained with gradient descent and a final quantized model is created by approximating each weight’s distribution by a point-mass.

More recently, some works on quantization have explored ways to assign different precisions to parameter groups in a neural network (Wu et al., 2018; Wang et al., 2019; Dong et al., 2019; Yang et al., 2021) – such methods, however, remain a minority in the quantization literature. DNAS (Wu et al., 2018) uses neural architecture search to map candidate precisions to different parameter groups. HAQ (Wang et al., 2019) uses reinforcement learning to learn a quantization policy. HAWQ (Dong et al., 2019) uses second-order information to allocate precisions to different parameter groups.

Closest to our work is BSQ (Yang et al., 2021), which introduces new variables that are trained with gradient-based methods, which are then used to allocate precisions throughout the network. It operates by first mapping each real-valued weight to a bitstring variable whose length is chosen a-priori. These variables are then iteratively trained with gradient descent and pruned based on their magnitudes, resulting in a decrease in precision whenever a component (a bit) of the bitstring is removed. Finally, the bitstrings are mapped back to weights, and the quantized model undergoes fine-tuning by adopting straight-through estimators for the quantized weights.

Lastly, Fan et al. (2021) improve the performance of quantized networks by randomly selecting a subset of weights to be quantized during training while keeping the remaining parameters in their original format. While our approach also uses randomness to improve quantization in some fashion, the form of noise samples, along with how and why they are used, are vastly different.

19 Method

19.1 Formalizing the Quantization Problem

The quantization problem we address involves finding an optimal low-precision representation for the parameters of a neural network. In our formulation, each weight is assigned a precision (number of bits) so that the overall model uses as few bits as possible while preserving its predictive performance. Unlike traditional quantization methods that fix the precision in advance, our approach treats precision as an optimization variable that can vary across individual parameters.

As in the previous chapters, we assume that the dataset $D$ is chosen a-priori and remains fixed, containing samples (and, when applicable, labels). Consequently, our formulation of the quantization problem – and the design of our proposed heterogeneous quantization method – does not depend on the nature of the underlying task.

We start by letting $f:\theta\mapsto f(\theta)$ be a neural architecture parameterized by $\Theta\subseteq\mathbb{R}^{d}$: for any $\theta\in\Theta$, $f(\theta)$ is a network that maps inputs from a pre-defined dataset $D$ to outputs aligned with the underlying task. We directly define a loss function $\mathcal{L}:f(\theta)\mapsto\mathcal{L}(f(\theta))\in\mathbb{R}$ that measures the loss of $f(\theta)$ on $D$.

Consider the problem of finding a parameter setting $\theta\in\Theta$ where each component $\theta_{i}$, $i\in[d]$, is represented by exactly $p_{i}\in\mathbb{N}$ many (signed) bits given a bit-value map $(v_{1},v_{2},\dots)$ that assigns a scalar $v_{j}\in\mathbb{R}$ to each position $j\in\mathbb{N}$ in a bit string. In other words, we have

[TABLE]

where $b_{i,j}\in\{\pm 1\}$ is the $j$’th bit used to represent $\theta_{i}$ and $(v_{j})_{j}$ is the bit-value map.

Let

[TABLE]

be the set of all possible values that each component of $\theta$ can take. We will assume w.l.o.g. that the bit-value map is (countably) infinite and that $\mathbb{V}^{d}\subseteq\Theta$.

Next, let $V$ be the function that maps bit strings $b\in\{\pm 1\}^{d\times\infty}$ and precision values $p\in\mathbb{N}^{d}$ to parameter values $\theta\in\mathbb{V}^{d}$ element-wise:

[TABLE]

We can then formalize the mixed precision problem as finding a set of bit precisions $p\in\mathbb{N}^{d}$ and bit strings $b\in\{\pm 1\}^{d\times\infty}$ such that the total precision $\sum_{i=1}^{d}p_{i}$ is minimized and the parameter setting $\theta=V(b,p)\in\mathbb{V}^{d}$ achieves some target suboptimality $\delta$:

Definition 5.1**.**

*(Mixed Precision Problem)

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, the mixed precision problem is:*

[TABLE]

where $V:\{\pm 1\}^{d\times\infty}\times\mathbb{N}^{d}\to\mathbb{V}^{d}\subseteq\Theta$ is defined in Equation (39), $\mathcal{L}^{*}$ is the smallest achievable loss by the architecture $f$, and $\delta\geq 0$ is the suboptimality tolerance.

This problem poses a few obstacles: first, it involves a search over multiple binary values for each of the $d$ parameters of the network; second, and most importantly, the derivative w.r.t. each integer precision $p_{i}$ is undefined, making gradient-based methods inapplicable.

An alternative approach is to directly optimize $\theta\in\mathbb{V}^{d}$ while adopting its finite-precision representation to evaluate the loss objective:

Definition 5.2**.**

*(Mixed Quantization Problem)

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, the mixed quantization problem is:*

[TABLE]

where $Q:\mathbb{V}^{d}\times\mathbb{N}^{d}\to\mathbb{V}^{d}$ maps $\theta,p$ to a finite-precision representation of $\theta$ that takes exactly $p$ many bits, $\mathcal{L}^{*}$ is the smallest achievable loss by the architecture $f$, and $\delta\geq 0$ is the suboptimality tolerance.

To define $Q$ precisely we will first introduce a notion of inverse for $V$ (a ‘notion’ since $V$ is not generally bijective). For any $\theta_{i}\in\mathbb{V}$, we let $V^{-1}(\theta_{i})$ denote a setting $(b_{i},p_{i})$, with $p_{i}\in\mathbb{N}$ and $b_{i}\in\{\pm 1\}^{\infty}$ such that $V(b_{i},p_{i})=\theta_{i}$ and, moreover, for any $(b_{i}^{\prime},p_{i}^{\prime})$ such that $V(b_{i}^{\prime},p_{i}^{\prime})=\theta_{i}$, it follows that $p_{i}^{\prime}\geq p_{i}$. That is, $V^{-1}$ maps each element $\theta_{i}\in\mathbb{V}$ to a precision-bitstring pair that perfectly represents $\theta_{i}$ using the least number of bits. We also define $V^{-1}_{p}(\theta_{i})=p_{i}$ and $V^{-1}_{b}(\theta_{i})=b_{i}$ where, as before, $V^{-1}(\theta_{i})=(b_{i},p_{i})$.

Then, we can define $Q$ by

[TABLE]

i.e., the value induced by the shortest bit string that represents $\theta$, but truncated to $p_{i}$ elements. Note that this yields

[TABLE]

which will be a key property in the proofs below.

While it might be tempting to see $Q$ as a quantization mapping, it not always acts as one. For example, consider the bit-value map given by $v_{j}=2^{1-j}$, where $\theta_{i}=1$ can be represented by $p^{(1)}=1$, $b_{i}^{(1)}=(1,1,1,1,\dots)$, by $p^{(2)}=1$, $b_{i}^{(2)}=(1,-1,-1,-1,\dots)$, among other possibilities. In this case, both $V^{-1}(1)=(b^{(1)},p^{(1)})$ and $V^{-1}(1)=(b^{(2)},p^{(2)})$ are valid choices since $p^{(1)}=p^{(2)}=1$. For the former we have $Q(1,2)=\frac{3}{2}$, while for the latter we get $Q(1,2)=\frac{1}{2}$, which are not quantizations of $\theta_{i}=1$ in the common sense since they are not representations of $1$ using fewer bits than necessary.

With this definition of $Q$ we can show that the optimization problems in Definitions 5.1 and 5.2 are equivalent (under $V$ and $V^{-1}$).

Lemma 5.1**.**

For any setting $(b,p)$ that satisfies $\mathcal{L}(f(V(b,p)))\leq\mathcal{L}^{*}+\delta$ in Definition 5.1, we have that $(\theta=V(b,p),p)$ satisfies $\mathcal{L}(f(Q(\theta,p)))\leq\mathcal{L}^{*}+\delta$ in Definition 5.2.

Proof.

By definition, we have:

[TABLE]

Therefore, the parameter setting induced by $V(p,b)$ in Definition 5.1 will be equal to the one induced by $Q(\theta,p)$ in Definition 5.2, and hence the losses will be evaluated at the same point and satisfiability follows. ∎

Lemma 5.2**.**

For any setting $(\theta,p)$ that is a minimizer of the problem in Definition 5.2, we have that $(b=V^{-1}_{b}(\theta),p)$ satisfies $\mathcal{L}(f(V(b,p)))\leq\mathcal{L}^{*}+\delta$ in Definition 5.1.

Proof.

Since $(\theta,p)$ minimizes $\sum_{i=1}^{d}p_{i}$ by assumption, we have that no $\theta_{i}$ can be represented with less than $p_{i}$ many bits and hence $p=V^{-1}_{p}(\theta)$. Therefore

[TABLE]

It then follows that the parameter setting induced by $Q(\theta,p)=\theta$ in Definition 5.2 will be equal to the one induced by $V(b,p)$ in Definition 5.1, and hence the losses will be evaluated at the same point and satisfiability follows. ∎

With the two Lemmas we can prove that the two problems are indeed equivalent:

Corollary 5.1**.**

The optimization problems in Definitions 5.1 and 5.2 are equivalent under $V$ and $V^{-1}$: for any $(b,p)$ that minimizes (40), we have that $(\theta=V(b,p),p)$ minimizes (41), and for every $(\theta,p)$ that minimizes (41) we have that $(b=V^{-1}_{b}(\theta),p)$ minimizes (40). Moreover, the induced model $f(\theta)$ will be the same in all cases.

Proof.

• •

(41) $\to$ (40): assume for the sake of contradiction that $(b=V^{-1}_{b}(\theta),p)$ is suboptimal in (40), then there exists a satisfiable $(b^{\prime},p^{\prime})$ with $\|p^{\prime}\|<\|p\|$, but from Lemma 5.1 it follows that $(\theta=V(b^{\prime},p^{\prime}),p^{\prime})$ is satisfiable in (41), which contradicts the optimality of $(\theta,p)$.

• •

(40) $\to$ (41): assume for the sake of contradiction that $(\theta=V(b,p),p)$ is suboptimal in (41), then there exists a satisfiable $(\theta^{\prime},p^{\prime})$ with $\|p^{\prime}\|<\|p\|$, but from Lemma 5.2 it follows that $(b=V^{-1}_{b}(\theta^{\prime},p^{\prime}),p^{\prime})$ is satisfiable in (40), which contradicts the optimality of $(b,p)$.

∎

With this, we have shown that optimizing the quantized weights directly, as in Definition 5.2, is equivalent to the original problem of optimizing bit-strings of arbitrary length in Definition 5.1. Although we have simplified the search space significantly, note that gradient-based methods remain unfeasible since the gradient w.r.t. $p$ is still undefined and $Q$ is piece-wise constant,

19.2 Re-framing the Quantization Problem

We now present a sequence of steps to re-frame the original quantization problem in an equivalent way which is amenable to stochastic approximations. A key difference from the previous chapters is that we rely on an additional assumption to guarantee that the re-framed problem remains equivalent to the original one.

We start by defining

[TABLE]

which allows us to write

[TABLE]

Next, we consider the following assumption: if $(\theta_{i},p_{i})$ is satisfiable, then $(\theta_{i},p_{i}^{\prime})$ is satisfiable for any $p_{i}^{\prime}\geq p_{i}$ (i.e. assigning more bits to a parameter preserves satisfiability). This can be formally written as

[TABLE]

and is the core assumption for our method.

Using the definition of $R$ and letting $w=Q(\theta,p)$, we get from the above that

[TABLE]

i.e., using the trinary system, this means that if a bitstring $(1,1,0,0,0,\dots)$ is satisfiable, then any bitstring $(1,1,\pm 1,\pm 1,\pm 1,\dots)$ will also be satisfiable.

Now, we can re-frame the original mixed-quantization problem as having infinitely many constraints:

Definition 5.3** (Re-framed Mixed Quantization Problem).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. If Equation (49) holds for any $w\in\mathbb{V}^{d}\subseteq\Theta$, then the mixed quantization problem can be rewritten as:

[TABLE]

which is equivalent to the problem in Definition 5.2.

19.3 Approximating the Quantization Problem

Now that we have re-framed the problem as one with infinitely many constraints, we are ready to employ our approximation strategy.

Note that, for $p^{\prime}_{i}>p_{i}=V^{-1}_{b}(w_{i})$,

[TABLE]

where $V^{-1}_{b}(w_{i})$ admits any configuration for all bits after the $V^{-1}_{b}(w_{i})$-pth one. Therefore, we assume that $\{R(w_{i},p_{i}^{\prime})~|~p_{i}^{\prime}>p_{i}=V^{-1}_{p}(w_{i})\}$ is dense in some interval $I(w_{i},p_{i})=[l,u]\subset\mathbb{V}$.

We first approximate the infinitely many constraints in Definition 5.3 by a single constraint on the expected loss over possible values $\epsilon$ for $R(w,p)$:

[TABLE]

where $\mathbb{P}$ is some probability distribution with support $I(w_{i},p_{i})$.

Computing the expected loss above is still generally intractable, therefore we estimate by using $K$ samples:

[TABLE]

Our approximation is given by adopting the above estimate for the expected loss, relaxing the discrete domain of $p$, and using Lagrange multipliers to yield an unconstrained problem:

Definition 5.4** (Approximate Mixed Quantization Problem).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then the approximate mixed quantization problem is

[TABLE]

where $\mathbb{P}$ is some probability distribution with support $I(w_{i},p_{i})$.

Note that the derivation so far is agnostic to the underlying bit-value map $(v_{j})_{j}$. Moreover, the approximate problem given above still poses a key obstacle: it is unclear how to choose $\mathbb{P}$ such that the gradients w.r.t. $p$ are well-defined and informative.

To circumvent this remaining limitation, we first assume that the bit-value map is given by $v_{j}=2^{1-j}$ i.e., fixed-point binary representation. In this case, for any $w_{i}$, the distribution $\mathcal{U}(\pm 1)$ for all bits after the $V^{-1}_{p}(w_{i})$-th one induces $\mathbb{P}(I(w_{i},p_{i}))=\mathcal{U}(\pm 2^{1-p_{i}})$. Instead of having $R(w_{i},p_{i})\sim\mathcal{U}(\pm 2^{1-p_{i}})$, we can write $R(w_{i},p_{i})=2^{1-p_{i}}\cdot\epsilon$ with $\epsilon\sim\mathcal{U}(\pm 1)$ to yield well-defined gradients w.r.t $p$.

Next, we reparameterize $p$ to avoid having to perform projections. For $p_{i}\in[1,\infty)$, we have $2^{1-p_{i}}\in(0,1]$, which we reparameterize as $\sigma(s_{i})$ for $s_{i}\in\mathbb{R}$, i.e., $s=\sigma^{-1}(2^{1-p})$. Finally, note that, for the special case $v_{j}=2^{1-j}$, we have

[TABLE]

which characterizes the domain of $w$.

Definition 5.5** (Approximate Mixed Quantization Problem (Fixed-point)).**

Let $f$ be a neural architecture with weight space $\Theta\subseteq\mathbb{R}^{d}$. For any $\theta\in\Theta$, $\mathcal{L}(f(\theta))\in\mathbb{R}$ denotes the loss incurred by $f(\theta)$ on the fixed dataset $D$. Then, for the bit-value map $v_{j}=2^{1-j}$, the approximate mixed quantization problem is

[TABLE]

The problem above is fully differentiable w.r.t. $w$ and $s$, where the latter is a reparameterization for the precisions $p$. Like our previous approximations, the objective can be optimized with gradient descent, where the network weights $w$ and the quantization scheme induced by $s$ are trained jointly in an end-to-end fashion. It is a stochastic approximation since we use $K<\infty$ noise samples to approximate the expected loss, but we use new samples at each gradient descent iteration in order to decrease the estimation error without any computational overhead.

19.4 The Proposed Quantization Method

Although the problem given in Definition 5.5 required a sequence of approximations to be derived, it admits an intuitive description and motivation that relies on a connection between quantization and perturbations. More specifically, if we assume that a weight $w$ can be perturbed in any direction by at least $\epsilon$ without degrading the performance of the network, then we can safely represent $w$ with $p$ bits as long as the quantization error does not exceed $\epsilon$ – that is, $|w-q(w,p)|\leq\epsilon$.

In other words, if we know the largest perturbation that each weight admits (its perturbation limit) without yielding performance degradation, then we can easily assign a precision to each weight: it suffices to choose the smallest number of bits such that the quantization error falls below the perturbation limit of the corresponding weight.

Our method works by estimating the perturbation limit of each parameter to be quantized, which is achieved by directly optimizing the magnitude of the weight perturbations through a novel loss function. We call our method SMOL.

Once the perturbation limit of each weight has been estimated through optimization by our method, we assign per-weight precisions by mapping each perturbation limit to a number of bits.

A key aspect of our proposed loss function lies in the fact that it is fully differentiable w.r.t. $s$; hence, gradient-based methods like SGD and Adam can be applied off-the-shelf to optimize both the original weights $w$ and the auxiliary variables $s$. This enables the parameters $s$ to be seen as being part of the model itself, allowing for our method to be easily combined with higher-order optimizers, neural architecture search, and other algorithms that operate on networks. After training, we map the final values of $s$ to precisions via some function $\lceil\cdot\rfloor$ that outputs integers e.g., rounding or truncation:

[TABLE]

The resulting tensor $p$ will have the same shape as $w$, and its components represent the number of bits assigned to each parameter in $w$. Having allocated a precision to each weight parameter, we can discard the auxiliary variables $s$ and use quantized weights $w_{q}=Q(w,p)$ to compute the model’s predictions instead of applying perturbations. This will typically lead to non-negligible changes in the model’s activations, which we circumvent by fine-tuning the model by further optimizing $w$ to minimize the training loss. Following prior work, we use straight-through estimators to optimize $w$ since $Q$ is non-differentiable, i.e., we set $\nabla_{w}\mathcal{L}=\nabla_{w_{q}}\mathcal{L}$ and perform gradient descent on $w$.

Lastly, note that inverting the $s\to p$ mapping offers a way to initialize $s$ given a desired initial precision $p_{init}$, more specifically we set $s_{init}=-\ln\left(2^{p_{init}-1}-1\right)$. For example, adopting an initial precision $p_{init}=8$ results in $s_{init}=-\ln(2^{8-1}-1)=-\ln(127)$, and the perturbation limit estimate will start as $\sigma(s_{init})=2^{1-p_{init}}=2^{-7}$ for all weights $w$ of the network.

Our method is also applicable if groups of parameters must share the same precision value e.g., the layer-wise setting where all parameters of each layer are represented with the same number of bits. In this case, we assign each parameter group $i$ to a single component $s_{i}$ of $s$, and when applying perturbations to the weights in the group we scale all the noise samples by the same scalar $\sigma(s_{i})$. At the end of training, we map $s_{i}$ to a single integer $p_{i}$ via (57) which is shared across the group.

Zero Precision Allocation.

A fundamental limitation of having each $i$’th bit map to either $+2^{1-i}$ or $-2^{1-i}$ is that zero weights cannot be represented: the possible values that a 1-bit weight can assume are $\{-1,+1\}$, for a 2-bit weight $\{-1.5,-0.5,+0.5,+1.5\}$, and moreover a quantized weight cannot assume the value [math] regardless of its precision. However, in our setting – where we can assign a different precision to each weight – we can directly re-define the quantization function $q$ to map any $w$ to [math] whenever $p=0$, hence introducing the notion of zero-precision weights. This is analogous to the procedure of assigning zero precision to a filter in BSQ, which leads to the corresponding convolution to be completely skipped when computing a model’s outputs.

We propose to assign zero precision to a weight $w$ whenever $|w|\leq|w-q(w,p)|$. Since the quantization function $q$ maps $w$ to the closest value that is representable with $p$ bits, whenever a weight’s precision is set to zero due to our proposed strategy, the induced quantization error is guaranteed not to increase. This follows since prior to changing $p$ the quantization error is $|w-q(w,p)|$; but once we set $p=0$, it becomes $|w-q(w,0)|=|w-0|=|w|$, which cannot lead to an increase since the condition is precisely $|w|\leq|w-q(w,p)|$.

For example, $q(w=0.2,p=2)=0.5$ since it is the value in $\{-1.5,-0.5,+0.5,+1.5\}$ that is closest to $w=0.2$, while $q(w=0.2,p=0)=0$ following our re-definition of $q$ yields a quantization error of $|0.2-0|=0.2$. On the other hand, for $p=2$ we have $|0.5-0.2|=0.3$. Hence, assigning zero precision in this case not only frees up $2$ bits but also decreases the quantization error by $0.1$.

One advantage of adopting this procedure to assign zero precisions to weights is that it only changes $q$ and hence the quantized network, therefore not affecting the procedure described in the previous section. In other words, one can allocate precisions to weights by optimizing perturbations as described previously, and then quantize the model separately with and without zero precision allocation.

This results in two quantized models with different precision assignments, hence we can obtain two networks by training the auxiliary variables $s$ only once. The notion of zero precisions also unifies quantization and pruning, since in practice assigning zero precision is equivalent to pruning a weight.

20 Experimental Setup

20.1 Datasets

CIFAR-10.

The CIFAR-10 dataset (Krizhevsky, 2009) consists of $32\times 32$ color images split into 50,000 and 10,000 training and test samples, each belonging to one out of 10 classes. We pre-process the data by applying channel-wise normalization to all images using statistics computed from the training set. We use the standard data augmentation pipeline from He et al. (2016a), which includes random crops and horizontal flips.

ImageNet.

We employ the ILSVRC 2012 subset of ImageNet (Russakovsky et al., 2015), which contains roughly 1.28 million training images and 50,000 validation images belonging to 1,000 different object classes. We use single $224\times 224$ center-crop images for both training and validation. We follow Gross and Wilber (2016) for pre-processing and data augmentation, which consists of scale augmentation (random crops of different sizes and aspect ratios are rescaled back to the original size with bicubic interpolation), photometric distortions (random changes to brightness, contrast, and saturation), lighting noise, and horizontal flips. Channel-wise normalization is employed using statistics from a random subset of the training data.

IWSLT’14.

We use the IWSLT’14 German-to-English dataset, a popular benchmark for low-resource neural machine translation. It contains roughly 160,000 sentence pairs, with 7,283 sentences used for validation and 6,750 for testing. Following prior works, we apply byte-pair encoding with a joint vocabulary of 10,000 tokens.

20.2 Models

ResNet-20.

For CIFAR-10 classification, we employ ResNet-20, a residual network composed of multiple residual blocks, each containing two $3\times 3$ convolutions with batch normalization and ReLU activations. This network provides a canonical baseline to evaluate quantization on CIFAR-10.

MobileNetV2.

Also on CIFAR-10, we use MobileNetV2, a lightweight convolutional network commonly adopted in resource-constrained settings. It relies on depthwise separable convolutions and linear bottlenecks, significantly reducing the FLOPs required for inference compared to standard CNNs.

ShuffleNet.

We also evaluate quantization on ShuffleNets for CIFAR-10. These are highly efficient architectures that leverage channel shuffle operations, minimizing computational and memory costs while maintaining accuracy. ShuffleNets provide a complementary benchmark to MobileNetV2 for quantization of highly efficient architectures.

ResNet-18 and ResNet-50.

On ImageNet, we use ResNet-18 and ResNet-50, allowing for direct comparisons with existing quantization methods. These architectures adopt bottleneck residual blocks that consist of a $1\times 1$ depth-reducing convolution, a $3\times 3$ dept-preserving convolution, and a $1\times 1$ depth-increasing convolution, each followed by batch normalization and ReLU activations.

DCGAN.

For image generation on CIFAR-10, we use DCGAN (Radford et al., 2016), a widely adopted generative network whose generator consists of four transposed convolutions with batch norm and ReLU activations, while its discriminator adopts four strided convolutional layers with batch norm and LeakyReLU activations.

Transformer.

For IWSLT’14, we adopt a 6-layer encoder-decoder Transformer model (Vaswani et al., 2017). Each encoder an decoder block includes multi-head attention followed by token-wise residual feedforward layers and layer normalization.

Quantized Activations on ImageNet.

We follow BSQ (Yang et al., 2021) and replace all ReLU modules by ReLU6 throughout the network, resulting in outputs constrained to the $[0,6]$ interval. Activations are not quantized prior to fine-tuning i.e., precision training with SMOL uses full-precision activations, which are only quantized once precisions have been allocated and fine-tuning has started. All our experiments that quantize activations consider 4-bit precisions i.e., the activation tensors are quantized using $2^{4}=16$ different values.

Also following BSQ, we use straight-through estimators to allow for gradient flow through the activation quantization procedure. The quantization values are uniform over half of the activation range – typically $[0,3]$, which results in the full-precision activations being quantized to one of the 16 values in the set $\{0,\frac{1}{5},\frac{2}{5},\dots,\frac{14}{5},\frac{15}{5}\}$.

20.3 Training

We evaluate our method in the tasks of quantizing CNNs trained for image classification and generation. For all experiments, we adopt an initial precision $p_{init}=8$, which corresponds to initializing each component of the new parameter $s$ as $-\ln(2^{7}-1)\approx-4.84$.

We use the floor operation to map real-valued precisions to integers: based on our preliminary experiments this more aggressive rounding operation yields more compact models and rarely results in performance degradation.

For all experiments we train the auxiliary parameters $s$ with Adam (Kingma and Ba, 2015), using the default learning rate of $10^{-3}$ and no weight decay – all its other hyperparameters are set to their default values.

CIFAR.

We adopt the standard data augmentation procedure of applying random translations and horizontal flips to training images, and train each network for a total of 650 epochs: the precisions are trained with SMOL for the first 350 while the remaining 300 are used to fine-tune the weights while the precisions remain fixed. Note that this training budget assigned to our method is considerably smaller than BSQ’s 1000 total epochs which are split between pre-training, precision allocation, and fine-tuning.

Following prior work, we keep the batch normalization parameters in full-precision as they represent a small fraction of the network’s total parameters. Like in BSQ, weights of parameterized shortcut connections are also kept in full-precision – namely, shortcuts that consist of $1\times 1$ convolutions followed by normalization in ResNet-20 and MobileNetV2.

To train the weights we use SGD with a momentum of $0.9$ and an initial learning rate of $0.1$, which is decayed at epochs 250, 500, and 600. We use a batch size of 128 and a weight decay of $10^{-4}$ for ResNet-20, $4\cdot 10^{-5}$ for MobileNetV2, and $5\cdot 10^{-4}$ for ShuffleNet.

When training ResNet-20 networks on CIFAR-10, we used $\lambda\in\{10^{-6},7\cdot 10^{-7},5\cdot 10^{-7}\}$ when running SMOL, where larger values for $\lambda$ result in less bits per parameter: $\lambda=10^{-6}$ resulted in a network with $2.1$ bpp while $\lambda=5\cdot 10^{-7}$ yielded a model with $2.8$ bpp. For MobileNetV2 we used $\lambda\in\{10^{-7},2\cdot 10^{-7}\}$, while for ShuffleNet we adopted $\lambda\in\{5\cdot 10^{-8},7\cdot 10^{-10}\}$

ImageNet.

For both ResNet-18 and ResNet-50 we train the weight parameters with SGD, a momentum of 0.9, a weight decay of $10^{-4}$ and a batch size of 256 which is distributed across 4 GPUs. We follow LQ-Nets in terms of data augmentation.

We train ResNet-18 for a total of 180 epochs: the first 120 are used for precision training and the last 60 for fine-tuning, and SGD has an initial learning rate of 0.1 which is decayed by 10 at epochs 45, 90, 150, and 165.

For ResNet-50, we start from a pre-trained, full-precision model and train for 100 epochs: allocating the first 60 for precision training and the remaining 40 for fine-tuning. An initial learning rate of $0.01$ is decayed by 10 at epoch $30$ for the precision training phase, while fine-tuning starts with the same learning rate of $0.01$ which is decayed by 10 at epochs 15 and 30. Note that, as in the CIFAR-10 experiments, our training budget is considerably smaller than BSQ’s, which also starts from a pre-trained model but has a budget of 180 additional epochs.

For our ImageNet experiments, we adopted $\{10^{-6},10^{-8}\}$ and $\{10^{-7},10^{-8}\}$ as values for $\lambda$ when training ResNet-18 and ResNet-50 networks, respectively. Different values for $\lambda$ were required (compared to the ones we used for CIFAR-10) due to the ImageNet ResNets having considerably more parameters than the ResNet-20 model we adopted for CIFAR-10: note that our regularizer is a sum over all precisions instead of, for example, an average.

Image Generation.

Models are trained with the binary cross-entropy loss using Adam with a learning rate = $2\cdot 10^{-4}$ and ($\beta_{1}$, $\beta_{2}$) = (0.5, 0.999). We only quantize the weights of the generator since it is the network used for deployment.

For BSQ, we first train a full-precision DCGAN for 30 epochs, quantize its weights to 8-bits, and conduct 100 epochs of precision learning with a pruning interval of 10 epochs and $\lambda=2\cdot 10^{-3}$. The models are then fine-tuned for 30 epochs, with a $10\times$ decayed learning rate. Similarly, for SMOL we train for a total of 160 epochs: 130 for precision training followed by 30 epochs for fine-tuning.

For image generation we used $\lambda\in\{2\cdot 10^{-5},10^{-5},5\cdot 10^{-6},2\cdot 10^{-6},10^{-6}\}$, where the most compact model (0.2 bpp) was achieved with $\lambda=2\cdot 10^{-5}$ along with zero precision allocation. In most cases we saw a decrease of between 1 and 2 bpp when enabling zero precision allocation: training a DCGAN with $\lambda=10^{-5}$ results in 0.5 bpp with zero precision allocation and 1.7 without it.

Neural Machine Translation.

The Transformer models is trained for a total of 50 epochs, where the first 30 are used by SMOL to optimize precisions and the remaining 20 for fine-tuning. All weights are quantized except for the layer normalization parameters.

20.4 Evaluation

Average Number of Bits.

To compare different methods we measure the performance and the size of the resulting network. We report the average number of bits assigned to the model’s weights (the sum of all precisions divided by the number of weights), which we refer to as ‘average bpp’, along with the compression ratio relative to a full-precision model, which equals to 32 divided by the average bpp.

Test Accuracy and Top-1/Top-5 Accuracy.

For the CIFAR datasets, we measure and report the accuracy on the 10,000 test samples. On ImageNet, we use the top-1 and top-5 accuracy on the 50,000 validation images. Top-5 accuracy is the fraction of samples for which the true label appears among the top five predicted classes.

21 Results

21.1 Quantizing Weights

CIFAR.

We first compare SMOL against different quantization methods on the small-scale CIFAR-10 dataset, adopting different networks to evaluate how aggressively each method can quantize weights without degrading the model’s generalization performance. Since prior works typically rely on other methods to quantize activations (e.g., using PACT (Choi et al., 2018) for activations while applying a new method to the weights), we only consider results with full-precision activations for CIFAR-10 as this isolates each method’s performance to its ability to quantize weights, leading to a more direct comparison.

ResNet-20 results are given in Table 8: SMOL comfortably outperforms BSQ and other competing methods by offering higher performance at lower precision. Comparing against BSQ’s $91.9\%$ accuracy at $2.7$ bpp, SMOL provides $0.6\%$ higher accuracy at $0.6$ lower bpp ($92.5\%$ at $2.1$ bpp). With zero-precision allocation (SMOL*), our method outperforms BSQ by $0.7\%$ at $1.0$ lower bpp ($92.6\%$ at $1.7$ bpp), and matches the performance of the full-precision model with a $18.8\times$ compression ratio.

When allocating layer-wise precisions (SMOL-L), we observe a $0.5\%$ higher accuracy at $0.3$ lower bpp compared to BSQ, showing that although per-parameter precisions improve efficiency, our method outperforms the state-of-the-art even when constrained to the less flexible, layer-wise setting (more details in Section 22.1). Figure 28 shows efficiency curves for BSQ and SMOL-L.

Table 9 presents results for MobileNetV2 and ShuffleNet: SMOL also comfortably outperforms BSQ, offering $0.7\%$ higher accuracy at $1.1$ lower bpp on MobileNetV2 ($94.8\%$ at $1.7$ bpp, compared to $94.1\%$ at $2.8$ bpp), and $0.2\%$ higher performance at $0.5$ lower bpp on ShuffleNet ($92.0\%$ at $2.9$ bpp, compared to $91.8\%$ at $3.4$ bpp), while outperforming the full-precision model in both cases.

ImageNet.

For the large-scale ImageNet classification task, we quantize the ResNet-18 and ResNet-50 models which allow for comparisons against LQ-Nets, DSQ, SLB, and BSQ.

Results in Table 10 show that SMOL outperforms competing methods while achieving higher performance than the full-precision baselines. On ResNet-18, our method offers $0.6\%$ higher accuracy than LQ-Nets at $1.7$ lower bpp ($69.9\%$ at $2.3$ bpp compared to $69.3\%$ at $4.0$ bpp), while also outperforming the full-precision model by $0.3\%$.

On ResNet-50, SMOL outperforms LQ-Nets at $2.2$ lower bpp, with an average number of bits of $0.8$ – lower than a binary network. With $4.1$ bpp, our method provides a $1.0\%$ improvement over the full-precision baseline, suggesting that the noise injection adopted by our method has additional regularizing effects that can further improve generalization. Performance by average precision plots for BSQ, SMOL, and LQ are given in Figure 29.

21.2 Quantizing GANs

We train a DCGAN (Radford et al., 2016) model on the CIFAR-10 dataset to perform unconditional image generation on CIFAR-10.

We randomly generate 10,000 samples for all methods, each assessed with Inception Score(IS) (Salimans et al., 2016) and Fréchet Inception Distance (FID) (Heusel et al., 2017a). As shown in Table 11, our method consistently outperforms BSQ, with higher generation quality at lower bpp, demonstrating generalization capability to the challenging task of quantizing GANs.

We drastically improve BSQ’s FID from $37.1$ at $3.9$ bpp to $29.9$ at only $3.5$ bpp. For BSQ at $2.8$ bpp, SMOL* achieves $7.2$ better FID with only $1.0$ bpp. Even when evaluated at an extremely low bpp of $0.2$, our method still generates images with good quality.

21.3 Quantizing Activations

In order to extend SMOL to train precisions for hidden activations, we introduce new trainable parameters to estimate the perturbation limit of activation outputs instead of weights. For an activation tensor $u$, we instantiate a new variable $s$ of the same shape which will be trained jointly with the network’s original parameters.

Similarly to the weight quantization case described in Section 19.4, at each training iteration $t$ we sample a tensor $\epsilon^{(t)}$ with the same shape as $u$, where each component is drawn uniformly from $[-1,+1]$, and generate perturbed activations $u+\frac{M}{2}\cdot\sigma(s)\odot\epsilon^{(t)}$, which are used in place of $u$ throughout the next layers of the network. The scalar $M$ denotes the range of activation function used to compute $u$, i.e., $M=1$ for sigmoid and $M=2$ for tanh activations, and is used to match the magnitudes of the activations and its perturbations. Since ReLU activations are unbounded, we use PACT (Choi et al., 2018) which clips values to $[0,\alpha]$ where $\alpha$ is a new trainable parameter – this yields $M=\alpha$. Once $s$ has been trained, we map its components to integer precisions which are used to quantize the activations $u$.

Table 12 shows the performance of a ResNet-20 trained on CIFAR-10 whose activations are quantized by PACT and SMOL (referred as SMOL-A): our method provides off-the-shelf improvements over PACT, offering higher accuracy at lower average bits per activation (bpa).

21.4 Computational Efficiency

A key question is whether per-parameter precisions can result in inference energy cost reductions. The power required to multiply a 2-bit and 3-bit weight with a 4-bit activation is $2.41\times$ and $3.83\times$ higher than what is required for a 1-bit weight; and the latency is $1.91\times$ and $2.10\times$ higher, respectively. These numbers are estimated using ripple-carry adder based multiplier designs (which are suitable for low-precision operations) for the corresponding precision settings (Brown and Vranesic, 2009). For the accumulation operations, we assume that the power and latency values are the same for different precision settings.

We take as an example the last convolutional layer of ResNet-20, for which BSQ assigns 2 bits for all parameters while our method assigns 1, 2, and 3 bits to 74%, 24.5%, and 1.5% of the parameters, respectively. In this case, the layer with precisions assigned by SMOL requires only 57.5% of computation power while improving latency by 36% compared to BSQ, which amounts to an energy cost reduction (power x latency) of 62.7%. Note that in real hardware designs, additional control overheads, e.g., around 25% (Park et al., 2018), are required to perform fine-grained mixed-precision operations. Although estimates, these suggest that a fine-grained precision allocation scheme can result in significant energy savings on hardware designed to support the corresponding arithmetic operations.

22 Experimental Analysis

22.1 Layer-wise Precision Pattern

In Section 21.1 we present results for SMOL when training layer-wise precisions on a ResNet-20 trained on CIFAR-10 (SMOL-L in Table 8), where higher performance under lower bpp is achieved compared to BSQ.

Figure 31 shows the precisions allocated to each layer of the ResNet-20 under three different values for $\lambda$: in all cases, later convolutional layers are assigned low precisions compared to earlier stages of the network. The first convolution, along with the fully-connected layer at the end of the network, are assigned significantly higher precision than other layers.

22.2 Balancing Precision Optimization and Fine-Tuning

In our main experiments we allocate roughly half of the training budget to precision training and the other half to fine-tuning i.e., further optimization of the weight parameters while applying quantization and adopting straight-through estimators. Here we show how the performance and size (measured in average number of bits per parameter) of the final model behaves under different ratios for the number of epochs allocated to precision training over the total training budget.

Here, we still train the models with $\lambda=7\cdot 10^{-7}$, but we change what how many of the total 650 epochs are used for precision training – the remaining ones are always allocated to fine-tuning the model.

Results are shown in Figure 32: there is significant change in the model’s bpp when the fraction of epochs allocated to precision training is lower than $\frac{250}{650}$, indicating that SMOL requires between 200 and 250 epochs to fully optimize the auxiliary variables $s$. For ratios larger than $\frac{250}{650}$ our method yields networks with similar bits-per-parameter (around $2.5$ bpp), but the test accuracy starts to decrease as the ratio increases due to fewer epochs being used to fine-tune the model. The best performance is achieved by allocating 350 epochs for precision training, which results in the remaining 300 epochs being assigned for fine-tuning.

22.3 Underlying Structure in Precision Patterns

To evaluate whether the per-parameter precision assignments learned by SMOL have an underlying structure or not, we set up an additional experiment which aims to re-train and evaluate a network after destroying any possible structure in its precision map. In particular, we start from a ResNet-20 model that has been fully trained and fine-tuned by SMOL, and proceed to re-train it under two different settings.

For the first, we re-initialize the weight parameters (using a different random seed) but fully preserve the precision assignments generated by SMOL i.e., each $i$-th weight $w_{i}$ with precision $p_{i}$ is randomly re-initialized ($w_{i}\sim\mathcal{D}_{init}$), but $p_{i}$ is kept the same. As for the second setting, we also apply a random permutation on the precision tensor of each layer i.e., weights $w_{i}$ and $w_{j}$ of the same layer have their precisions $p_{i}$ and $p_{j}$ swapped – with the goal of destroying any possible structure that the tensor $p$ might have.

We then re-train the two networks, but skipping precision training and hence allocating a budget of 300 epochs to weight training under quantization and straight-through estimators, akin to fine-tuning.

Table 13 and Figure 33 present results: randomly permuting (shuffling) the precisions yields significantly lower performance ($89.3\%$ compared to $91.5\%$), suggesting that the precision assignments generated by SMOL do have an underlying structure, which can be some form of per-layer organization i.e., allocating high or low precision to all elements in the same convolutional filter, or cross-layer structure i.e., feature maps (layer outputs) have low or high precision connections to both the previous and the next layer. We leave further the characterization of such structure to future work.

22.4 Quantizing Transformers

An immediate question is whether SMOL is able to efficiently quantize architectures of different families, for example Transformers which do not use convolutions and whose main component is the attention mechanism.

To answer this question, we run preliminary experiments where we train a standard encoder-decoder Transformer with 6 attention blocks on the neural machine translation IWSLT’14 German to English task, where we quantize all weights except for the layer normalization parameters. A total of 50 epochs were used for training: for SMOL, the first 30 were used to train the precisions and the remaining 20 for fine-tuning.

Results in Table 14 show that SMOL can match the performance of the full-precision model at $5.8$ bpp, which amounts to a $5.5\times$ compression ratio. At a lower bpp of $3.9$ ($8.2\times$ ratio), the BLEU score is lower by only $0.2$. Note that we use the same training budget that is commonly employed when training a full-precision model for this task, which is likely suboptimal for quantization. Therefore, although promising, these results are preliminary and can likely be improved by simply training for more epochs.

23 Discussion

In this chapter, we proposed a novel strategy to optimize precision assignments and quantized weights of a neural network. The core of our method, SMOL, lies in a stochastic approximation for the intractable mixed precision problem. Unlike prior works that require a global precision to be given a-priori, we allow for precisions to be trained jointly with a network’s weights in an end-to-end fashion.

23.1 Contributions

This chapter makes several key contributions:

• •

We develop a novel approximation for the intractable mixed precision problem, where parameter-wise precisions are free variables to be optimized. Our strategy provides proxy gradients w.r.t. precisions, allowing them to be trained jointly with the network’s parameters with gradient descent.

• •

We show that SMOL is capable of achieving state-of-the-art compression across different domains – from image classification with ResNets to machine translation with Transformers – while matching, and sometimes even surpassing, the performance of full-precision models.

23.2 Research Directions

Future research directions could focus on making our proposed method more hardware-friendly. Rather than assigning a different precision for each weight, which is difficult to leverage on accelerators and GPUs, one could restrict the precisions to hardware supported bitwidths (e.g., 1, 2, 4, 8) and apply them to continuous parameter blocks. Another direction is to expand the pool of adopted architectures and activations, such as applying SMOL to recurrent networks or vision transformers, as well as using it to quantize softmax activations in attention blocks. Finally, developing a fully deterministic approximation for the original quantization problem may yield an alternative method that is more stable, especially at very low precisions.

23.3 Impact

Following its publication, SMOL has inspired further work in heterogeneous and mixed-precision quantization for deep learning. Notably, Zhou et al. (2023) incorporate SMOL into a hardware co-design framework, constraining the precision assignment values and structure so it can be leveraged by existing hardware. By aligning the training procedure with hardware constraints, their SySMOL algorithm achieves practical gains in terms of compression and inference efficiency on CPUs and GPUs. In parallel, Shin et al. (2023) propose NIPQ, which further improves the idea of using additive noise as a proxy for quantization robustness by optimizing truncation thresholds for weights and activations. Together, these works demonstrate how our framework can be adopted to further advance algorithmic and system-level approaches to mixed-precision quantization.

Chapter 6 Leveraging Parameter Structure

24 Introduction

24.1 Motivation & Strategy

In the previous chapters, we addressed network efficiency through compression methods, where we optimized the network’s architecture, sparsity schemes, and precision assignments for quantization. In this chapter, we focus on a different but equally important dimension of efficiency in deep learning: the efficiency of the training process itself. Optimizing neural networks can be often prohibitive due to its heavy computational requirements, and the choice of optimizer plays a key role not only in training speed but also in final generalization performance.

Stochastic Gradient Descent (SGD) remains the dominant optimizer when training simple architectures for computer vision such as ResNets (He et al., 2016a, b), where components such as batch normalization (Ioffe and Szegedy, 2015) suffice to alleviate obstacles of training networks with many layers. On the other hand, adaptive methods such as Adam (Kingma and Ba, 2015) are typically adopted in natural language processing, where the state-of-the-art consists of sequence-to-sequence models (Hochreiter and Schmidhuber, 1997; Vaswani et al., 2017). This division persists despite the fact that adaptive methods should improve training efficiency across domains. A key reason is the belief that adaptive methods converge faster but yield models with worse generalization compared to SGD, particularly on vision tasks.

We revisit this conventional wisdom by analyzing adaptive methods both theoretically and empirically, and by proposing modifications based on rigorous analysis. Section 24.2 discusses previous works that have analyzed or proposed new adaptive optimizers, typically with the goal of closing the generalization gap. In Section 25.1, we discuss the stochastic non-convex optimization framework and formally define adaptive methods. Next, Section 25.2 revisits the role of adaptivity and shows that properly controlling it changes Adam’s behavior from non-convergent to offering a SGD-like convergence rate. Finally, Section 25.3 introduces AvaGrad, a novel adaptive optimizer inspired by our theoretical analysis that guarantees better convergence rates and improved hyperparameter separability. Subsequent sections present the adopted experimental setup, discuss empirical results comparing different adaptive methods, and provide further analysis, along with a final discussion on our contributions and impacts.

24.2 Related Work

Although many prior works have focused on analyzing adaptive methods under the online or stochastic convex frameworks, we focus on stochastic non-convex optimization which best captures neural network training. Zaheer et al. (2018) show that Adam and newly-proposed Yogi converge as $\mathcal{O}(1/T)$ given a batch size of $\Theta(T)$, a setting that neither captures the small batch sizes used in practice nor fits in the fully stochastic non-convex optimization framework – their analysis does not yield convergence for a batch size of $1$. Chen et al. (2019) prove a rate of $\mathcal{O}(\log T/\sqrt{T})$ for AdaGrad and AMSGrad given a decaying learning rate. Luo et al. (2019) proposes AdaBound, whose adaptability is decreased during training, but its convergence is only shown for convex problems (Savarese, 2019).

The correlation between the optimizer’s velocity and its parameter-wise learning rates is studied in Zhou et al. (2019b), which proposes making both independent of the current sample: the proposed method, AdaShift, is guaranteed to converge in the convex case but at an unknown rate. Xiaoyu and Orabona (2019) provide convergence rates for a form of AdaGrad without parameter-wise adaptation, also showing that AdaGrad converges but at an unknown rate. Chen et al. (2018) propose PAdam, which matches or outperforms SGD given proper tuning of a newly-introduced hyperparameter – in contrast to their work, we show that even Adam can match SGD given proper tuning and without introducing new hyperparameters.

25 Method

25.1 Non-convex Optimization

We consider problems of the form

[TABLE]

where $\mathcal{D}$ is a probability distribution over a set $\mathcal{S}$ of “data points”, $f_{s}:\mathbb{R}^{d}\to\mathbb{R}$ are not necessarily convex and indicate the instant loss for each data point $s\in\mathcal{S}$. As is typically done in non-convex optimization, we assume throughout the paper that $f$ is $L$-smooth, i.e., there exists $L$ such that

[TABLE]

for all $w,w^{\prime}\in\mathbb{R}^{d}$.

We also assume that the instant losses have bounded gradients, i.e., $\left\lVert{\nabla f_{s}(w)}\right\rVert_{\infty}\leq G_{2}$ for some $G_{2}$ and all $s\in\mathcal{S}$, $w\in\mathbb{R}^{d}$.

Following the literature on stochastic non-convex optimization Ghadimi and Lan (2013), we evaluate optimization methods in terms of number of gradient evaluations required to achieve small loss gradients. We assume that the algorithm takes a sequence of data points $S=(s_{1},\ldots,s_{T})$ from which it sequentially and deterministically computes iterates $w_{1},\ldots,w_{T}$, using a single gradient evaluation per iterate.

The algorithm then constructs a distribution ${\cal P}(t|S)$ over $t\in\{1,\ldots,T\}$, samples $t^{\prime}\sim{\cal P}$ and outputs $w_{t^{\prime}}$. We say an algorithm has a convergence rate of $\mathcal{O}(g(T))$ if

[TABLE]

where the expectation is over the draw of the $T$ data points $S\sim\mathcal{D}^{T}$ and the chosen iterate $w_{t}$, $t\sim{\cal P}(t|S)$.

Adaptive Methods.

We consider methods which, at each iteration $t$, receive or compute a gradient estimate $g_{t}\coloneqq\nabla f_{s_{t}}(w_{t})$ and perform an update

[TABLE]

where $\alpha_{t}\in\mathbb{R}$ is the global learning rate, $\eta_{t}\in\mathbb{R}^{d}$ are the parameter-wise learning rates, and $m_{t}\in\mathbb{R}^{d}$ is the update direction, typically defined in terms of momentum

[TABLE]

Note that this definition includes non-momentum methods such as AdaGrad and RMSProp, since setting $\beta_{1,t}=0$ yields $m_{t}=g_{t}$. While in (61) $\alpha_{t}$ can always be absorbed into $\eta_{t}$, our representation will be convenient throughout the paper. SGD is a special case of (61) when $\eta_{t}=\vec{1}$, and although it offers no adaptation, it enjoys a convergence rate of $\mathcal{O}(1/\sqrt{T})$ with either constant, increasing, or decreasing learning rates (Ghadimi and Lan, 2013). It is widely used when training relatively simple networks such as feedforward CNNs (He et al., 2016a; Huang et al., 2017).

Adaptive methods, e.g., RMSProp (Dauphin et al., 2015), AdaGrad (Duchi et al., 2011), Adam (Kingma and Ba, 2015) use

[TABLE]

with $v_{t}\in\mathbb{R}^{d}$ as an exponential moving average of second-order gradient statistics:

[TABLE]

Here, $m_{t}$ and $\eta_{t}$ are functions of $g_{t}$ and can be non-trivially correlated, causing the update direction $\eta_{t}\odot m_{t}$ not to be an unbiased estimate of the expected update. Precisely this “bias” causes RMSProp and Adam to present nonconvergent behavior even in the stochastic convex setting (Reddi et al., 2018).

25.2 The Role of Adaptivity

We start with a key observation to motivate our studies on how adaptivity affects the behavior of adaptive methods like Adam in both theory and practice: if we let $\alpha_{t}=\gamma\epsilon$ for some positive scalar $\gamma$, then as $\epsilon$ goes to $\infty$ we have

[TABLE]

where $\vec{\gamma}$ is the $d$-dimensional vector with all components equal to $\gamma$, and $d$ is the dimensionality of $v_{t}$ (i.e., the total number of parameters in the system). This holds as long as $v_{t}$ does not explode as $\epsilon\to\infty$, which is guaranteed under the assumption of bounded gradients.

In other words, we have that adaptive methods such as AdaGrad and Adam lose their adaptivity as $\epsilon$ increases, and behave like SGD in the limit where $\epsilon\to\infty$ i.e., all components of the parameter-wise learning rate vector $\eta_{t}$ converge to the same value. This observation raises two questions which are central in our work:

How does $\bm{\epsilon}$ affect the convergence behavior of Adam? It has been shown that Adam does not generally converge even in the linear case (Reddi et al., 2018). However, as $\epsilon$ increases it behaves like SGD, which in turn has well-known convergence guarantees, suggesting that $\epsilon$ plays a key, although overlooked, role in the convergence properties of adaptive methods. 2. 2.

Is the preference towards SGD for computer vision tasks purely due to insufficient tuning of $\bm{\epsilon}$? SGD is de-facto the most adopted method when training convolutional networks (Simonyan and Zisserman, 2015; Szegedy et al., 2015; He et al., 2016a, b; Zagoruyko and Komodakis, 2016; Xie et al., 2017), and it is believed that it offers better generalization than adaptive methods (Wilson et al., 2017). Moreover, recently proposed adaptive methods such as AdaBelief (Zhuang et al., 2020) and RAdam (Liu et al., 2020) claim success while underperforming SGD on ImageNet. However, it is not justified to view SGD as naturally better suited for computer vision, because SGD itself can be seen as a special case of Adam.

Adam’s Non-convergence: from Optimality to Stationarity.

We focus on the first question regarding how the convergence behavior of Adam changes with $\epsilon$. As mentioned previously,  Reddi et al. (2018) has shown that Adam can fail to converge in the stochastic convex setting. The next Theorem, stated informally, shows that Adam’s nonconvergence also holds in the stochastic non-convex case, when convergence is measured in terms of stationarity instead of suboptimality:

Theorem 6.1**.**

For any $\epsilon\geq 0$ and constant $\beta_{2,t}=\beta_{2}\in[0,1)$, there is a stochastic optimization problem for which Adam does not converge to a stationary point.

Note that the problem is constructed adversarially in terms of $\epsilon$. The problem considered in Theorem 3 of  Reddi et al. (2018), used to show Adam’s nonconvergence, has no dependence on $\epsilon$ because the proof assumes that $\epsilon=0$.

Adaptive Methods with Controlled Adaptivity.

The next result shows that for stochastic non-convex problems that do not depend on $\epsilon$, Adam actually converges like SGD as long as $\epsilon$ is large enough (or, alternatively, increases during training):

Theorem 6.2**.**

Assume that $f$ is smooth and $f_{s}$ has bounded gradients. If $\epsilon_{t}\geq\epsilon_{t-1}>0$ for all $t\in[T]$, then for the iterates $\{w_{1},\dots,w_{T}\}$ produced by Adam we have

[TABLE]

where $w_{t}$ is sampled from $p(t)\propto\frac{\alpha_{t}}{G_{2}+\epsilon_{t-1}}$.

Corollary 6.1**.**

Setting $\epsilon_{t}=\Theta(T^{p_{1}}t^{p_{2}})$ for any $p_{1},p_{2}>0$ such that $p_{1}+p_{2}\geq\frac{1}{2}$ (e.g. $\epsilon_{t}=\Theta(\sqrt{T}),\epsilon_{t}=\Theta(\sqrt[4]{Tt}),\epsilon_{t}=\Theta(\sqrt{t})$) and $\alpha_{t}=\Theta\left(\frac{\epsilon_{t}}{\sqrt{T}}\right)$ in Theorem 6.2 yields a bound of $\mathcal{O}(1/\sqrt{T})$ for Adam.

Together, the two theorems above give a precise characterization of how $\epsilon$ affects the theoretical behavior of Adam and other adaptive methods: not only is convergence ensured but a SGD-like rate of $\mathcal{O}(1/\sqrt{T})$ is guaranteed as long as $\epsilon$ is large enough. While Adam behaves like SGD in the limit $\epsilon\to\infty$, we show that it suffices for $\epsilon$ to be $\mathcal{O}(\sqrt{T})$ to guarantee a SGD-like convergence rate. We believe Theorem 6.2 is more informative than Theorem 6.1 for characterizing Adam’s behavior, as convergence analyses in the optimization literature typically consider non-adversarial examples.

At a first glance, the above statement seems to contradict Theorem 1 of Reddi et al. (2018), but note the difference in the order of quantifies. In Theorem 1 the optimization problem is designed according to a given fixed $\epsilon$, while in Theorem 6.2 $\epsilon$ is either increasing or fixed as a function of $T$, causing an implicit dependence on the underlying problem – in particular, achieving gradient norm less than some positive constant requires setting $T$ large enough in terms of $M$, $G_{2}$ and $\delta$.

Indeed, there is no contradiction since Theorem 6.1 sets $G_{2}$ to be large w.r.t. a given, fixed $\epsilon$, while Theorem 6.2 only guarantees small gradient norms with a fixed $\epsilon$ if its value is large w.r.t. $T$ (and consequently, also $G_{2}$). Note that $\epsilon_{t}\propto\sqrt{t}$ avoids implicit dependencies between $\epsilon$ and problem-specific constants $L$ and $G_{2}$.

For natural, non-adversarial problems, Theorem 6.2 better captures the behavior of Adam and suggests that adopting a large enough $\epsilon$ not only avoids nonconvergence, but also yields a $\mathcal{O}(1/\sqrt{T})$ rate similar to SGD. Note that $\alpha/(\sqrt{v}_{t}+\epsilon)\to\vec{1}$ for $\alpha=\epsilon\to\infty$, meaning that Adam degenerates to SGD (excluding the bias correction) as $\epsilon$ becomes sufficiently large, and thus must yield a similar empirical performance on non-adversarial tasks.

Adaptive Methods with Delayed Adaptivity.

We present a theoretical analysis on the convergence of adaptive methods, but instead of analyzing how $\epsilon$ affects the convergence of Adam, here we focus on better understanding why Adam can fail to converge for problems that depend on its hyperparameter settings.

We first note that the ‘adversarial’ problems designed to show Adam’s nonconvergence in Theorem 3 of Reddi et al. (2018) and our Theorem 6.1 exploit the correlation between $m_{t}$ and $\eta_{t}$ to guarantee that Adam takes overly conservative steps when presented with rare samples that contribute significant to the objective.

While Reddi et al. (2018) already propose a modification for Adam that guarantees its convergence, it relies on explicitly constraining the parameter-wise learning rates $\eta_{t}$ to be point-wise decreasing which can harm the method’s adaptiveness. We present a simple way to directly circumvent the fact that $m_{t}$ and $\eta_{t}$ are correlated without constraining $\eta_{t}$, guaranteeing a $\mathcal{O}(1/\sqrt{T})$ rate for stochastic non-convex problems while being applicable to virtually any adaptive method.

Our modification consists of employing a 1-step delay in the update of $\eta_{t}$, or equivalently replacing $\eta_{t}$ by $\eta_{t-1}$ in the method’s update rule for $w_{t+1}$. Although there is still statistical dependence between $m_{t}$ and $v_{t}$, this ensures that $\eta_{t}$ is independent of the current sample $s_{t}$, which the following result shows to suffice for SGD-like convergence:

Theorem 6.3**.**

Assume that $f$ is smooth and $f_{s}$ has bounded gradients for all $s\in\mathcal{S}$. For any optimization method that performs updates following (61) such that $\eta_{t}$ is independent of $s_{t}$ and $L_{\infty}\leq\eta_{t,i}\leq H_{\infty}$ for positive constants $L_{\infty}$ and $H_{\infty}$, setting $\alpha_{t}=\alpha^{\prime}/\sqrt{T}$ yields

[TABLE]

where $w_{t}$ is uniformly sampled from $\{w_{1},\dots,w_{T}\}$.

Moreover, if $s_{t}$ is independent of $Z\coloneqq\sum_{t=1}^{T}\alpha_{t}\min_{i}\eta_{t,i}$, then setting $\alpha_{t}=\alpha^{\prime}_{t}/\sqrt{T}$ yields

[TABLE]

where $w_{t}$ is sampled from $p(t)\propto\alpha_{t}\cdot\min_{i}\eta_{t,i}$.

25.3 AvaGrad

The bound in Equation (68) depends on the learning rate $\alpha_{t}$ and on both the squared norm and smallest value of the parameter-wise learning rate $\eta_{t}$, namely $\left\lVert{\eta_{t}}\right\rVert^{2}$ and $\min_{i}\eta_{t,i}$, enabling us to analyze how the relation between $\alpha_{t}$ and $\eta_{t}$ affects the convergence rate, including how the rate can be improved by adopting a learning rate $\alpha_{t}$ that depends on $\eta_{t}$.

Setting $\alpha_{t}^{\prime}=\left\lVert{\eta_{t}}\right\rVert^{-1}$ yields a bound on the convergence rate of

[TABLE]

Note that such bound is stronger than the one in Equation (67): given constants $L_{\infty}$ and $H_{\infty}$ as in Theorem 6.3, we have $L_{\infty}\leq\min_{i}\eta_{t,i}$ and $\left\lVert{\eta_{t}}\right\rVert\leq\sqrt{d}H_{\infty}$, yielding an upper bound of $\mathcal{O}(H/L\sqrt{T})$ that matches $(\ref{eq-simplerate})$ when $\alpha^{\prime}=H^{-1}$.

Note that, for $\eta_{t}=1/(\sqrt{v}_{t}+\epsilon)$, having $\alpha_{t}^{\prime}=\left\lVert{\eta_{t}}\right\rVert^{-1}$ is equivalent to normalizing $\eta_{t}$ prior to each update step, which is precisely how we arrived at AvaGrad’s update rule (with the exception of accounting for $d$, the dimensionality of $\eta_{t}$, when performing normalization).

Additionally, Theorem 6.3 predicts the existence of two distinct regimes in the behavior of Adam-like methods. Taking $\alpha^{\prime}=\Theta(H^{-1})$ minimizes the bound in Equation (67) and yields a rate of $\mathcal{O}(\frac{1}{\sqrt{T}}\frac{H}{L})=\mathcal{O}\left(\frac{1}{\sqrt{T}}\max\left(1,\frac{G_{2}}{\epsilon}\right)\right)$ once we take $L_{\infty}=(G_{2}+\epsilon)^{-1}$ and $H_{\infty}=\epsilon^{-1}$, which can be shown to satisfy $L_{\infty}\leq\eta_{t,i}\leq H_{\infty}$ for Adam-like methods.

In this case, the convergence rate depends on $\frac{G_{2}}{\epsilon}$, or, informally, how $v_{t}$ compares to $\epsilon$ ($G_{2}$ is an upper bound on the magnitude of the gradients, hence directly connected to $v_{t}$).

We now introduce AvaGrad, a novel adaptive method presented as pseudo-code in Algorithm 7. The key difference between AvaGrad and Adam lies in how the parameter-wise learning rates $\eta_{t}$ are computed and their influence on the optimization dynamics. In particular, AvaGrad adopts a normalized vector of parameter-wise learning rates, which we later show to be advantageous in multiple aspects: it yields better performance and easier hyperparameter tuning in practice, while in theory it results in better convergence rate guarantees.

For convenience, we also account for the dimensionality $d$ of $\eta_{t}$ (i.e., the total number of parameters in the system) when performing normalization: more specifically, we divide $\eta_{t}$ by $\lVert\eta_{t}/\sqrt{d}\rVert_{2}$ in the update rule, which is motivated by fact that the norm of random vectors increases as $\sqrt{d}$, and also observed to be experimentally robust to changes in $d$ (e.g., networks with different sizes). Alternatively, this normalization can be seen as acting on the global learning rate $\alpha_{t}$ instead, in which case AvaGrad can be seen as adding an internal, dynamic learning rate schedule for Adam.

Lastly, AvaGrad also differs from Adam in the sense that it updates $v_{t}$, the exponential moving average of gradients’ second moments, after the update step. This implies that parameters are updated according to the second-order estimate of the previous step i.e., there is a 1-step delay between second-order estimates and parameter updates. Such delay is fully motivated by theoretical analyses, and our preliminary experiments suggest that it does not impact AvaGrad’s performance on natural tasks.

26 Experimental Setup

26.1 Datasets

CIFAR-10 and CIFAR-100.

Each of the CIFAR datasets (Krizhevsky, 2009) consist of $32\times 32$ color images. CIFAR-10 is split into 50,000 and 10,000 training and test samples, each belonging to one out of 10 classes. CIFAR-100 has 100 classes with the same training/test set split. We pre-process the data by applying channel-wise normalization to all images using statistics computed from the training set. We use the standard data augmentation pipeline from He et al. (2016a), which includes random crops and horizontal flips.

ImageNet.

We employ the ILSVRC 2012 subset of ImageNet (Russakovsky et al., 2015), which contains roughly 1.28 million training images and 50,000 validation images belonging to 1,000 different object classes. We use single $224\times 224$ center-crop images for both training and validation. We follow Gross and Wilber (2016) for pre-processing and data augmentation, which consists of scale augmentation (random crops of different sizes and aspect ratios are rescaled back to the original size with bicubic interpolation), photometric distortions (random changes to brightness, contrast, and saturation), lighting noise, and horizontal flips. Channel-wise normalization is employed using statistics from a random subset of the training data.

Penn Treebank.

For language modeling, we use the Penn Treebank (PTB) corpus (Marcus et al., 1994), a widely adopted benchmark consisting of roughly one million words drawn from the Wall Street Journal articles. Rare words are replaced with a special unknown token, and the vocabulary is limited to 10,000 words. The dataset is split into 930k, 74k, and 82k tokens for training, validation, and testing, respectively.

26.2 Models

Wide ResNet 28.

We train Wide ResNets (Zagoruyko and Komodakis, 2016) with 28 layers on CIFAR-10 and CIFAR-100. Wide ResNets (WRNs) build upon pre-activation Residual Networks by increasing the number of channels by a factor. We adopt both WRNs 28-10 and WRNs 28-4, where the number of channels per convolutional layer are scaled by factors of 4 and 10, respectively.

ResNet-50.

For experiments on ImageNet, we use ResNet-50, a widely adopted benchmark architecture that achieves a strong balance between depth, computational efficiency, and performance. ResNet-50 is built from bottleneck residual blocks – each block consists of a $1\times 1$ depth-reducing convolution, a $3\times 3$ dept-preserving convolution, and a $1\times 1$ depth-increasing convolution, each followed by batch normalization and ReLU activations. Our ResNet-50 experiments are designed to test the scalability of sparsification methods to large-scale networks and complex datasets.

GGAN.

We use a Geometric GAN (GGAN, Lim and Ye (2017)) for image generation on CIFAR-10. It follows the same architecture as a DCGAN, where the generator has four transposed convolutions with batch norm and ReLU activations and the discriminator uses four strided convolutional layers with batch norm and LeakyReLU activations. Unlike standard DCGANs, GGANs are trained with the hinge loss.

LSTM.

For language modeling on Penn Treebank, we adopt the 3-layer LSTM (Hochreiter and Schmidhuber, 1997) model from Merity et al. (2018) with 300 hidden units per LSTM layer.

26.3 Training

CIFAR.

We adopt the same learning rate schedule as Zagoruyko and Komodakis (2016), decaying $\alpha$ by a factor of 5 at epochs 60, 120 and 160 – each network is trained for a total of 200 epochs on a single GPU. We use a weight decay of $0.0005$, a batch size of 128, a momentum of $0.9$ for SGD, and $\beta_{1}=0.9,\beta_{2}=0.999$ for each adaptive method.

We select a random subset of 5,000 samples from CIFAR-10 to use as the validation set when tuning $\alpha$ and $\epsilon$ of each adaptive method. We perform grid search over a total of 441 hyperparameter settings, given by all combinations of $\epsilon\in\{10^{-8},2\cdot 10^{-8},10^{-7},\dots,100\}$ and $\alpha\in\{5\cdot 10^{-7},10^{-6},5\cdot 10^{-6},\dots,5000\}$.

Next, we fix the best $(\alpha,\epsilon)$ values found for each method and train a Wide ResNet-28-10 on both CIFAR-10 and CIFAR-100, this time evaluating the test performance. We do not re-tune $\alpha$ and $\epsilon$ for adaptive methods due to the practical infeasibility of training a Wide ResNet-28-10 roughly 8000 times. We tune the learning rate $\alpha$ of SGD using the same search space as before, and confirm that the learning rate $\alpha=0.1$ commonly adopted when training ResNets He et al. (2016a, b); Zagoruyko and Komodakis (2016) performs best in this setting.

ImageNet.

We transfer the hyperparameters from our CIFAR experiments for all methods. The network is trained for 100 epochs with a batch size of $256$, split between 4 GPUs, where the learning rate $\alpha$ is decayed by a factor of 10 at epochs 30, 60 and 90, and we also adopt a weight decay of $10^{-4}$. Note that the learning rate of $0.1$ adopted for SGD agrees with prior work that established new state-of-the-art results on ImageNet with residual networks (He et al., 2016a, b; Xie et al., 2017).

Language Modeling.

We first perform hyperparameter tuning over all combinations of $\epsilon\in\{10^{-8},5\cdot 10^{-7},\dots,100\}$ and $\alpha\in\{2\cdot 10^{-4},10^{-3},\dots,20\}$, training each model for 500 epochs and decaying $\alpha$ by $10$ at epochs 300 and 400. Since $\epsilon$ affects AdaBelief differently and its official codebase recommends values as low as $10^{-16}$ for some tasks 222github.com/juntang-zhuang/Adabelief-Optimizer, ver. 9b8bb0a, we adopt a search space where candidate values for $\epsilon$ are smaller by a factor of $10^{-8}$ i.e., starting from $10^{-16}$ instead of $10^{-8}$.

We use a batch size of 128, BPTT length of 150, and weight decay of $1.2\times 10^{-6}$. We also employ dropout with the recommended settings for this model (Merity et al., 2018). Not surprisingly, our tuning procedure returned small values for $\epsilon$ as being superior for adaptive methods, with Adam, AMSGrad, and AvaGrad performing optimally with $\epsilon=10^{-8}$.

Next, we train the same 3-layer LSTM but with 1000 hidden units, transferring the $(\alpha,\epsilon)$ configuration found by our tuning procedure. For SGD, we again confirmed that the transferred learning rate performed best on the validation set when training the wider model.

GANs.

We adopt a batch size of 64 and train the networks for a total of 60,000 steps, where the discriminator is updated twice for each generator update. We train the GAN model with the same optimization methods considered previously, performing hyperparameter tuning over $\epsilon\in\{10^{-8},10^{-6},10^{-4}\}$ and $\alpha\in\{10^{-5},2\cdot 10^{-5},10^{-4},\dots,0.1\}$ for each adaptive method, and $\alpha\in\{10^{-6},2\cdot 10^{-6},10^{-5},\dots,1.0\}$ for SGD.

26.4 Evaluation

Test Accuracy and Top-1/Top-5 Accuracy.

For the CIFAR datasets, we measure and report the accuracy on the 10,000 test samples. On ImageNet, we use the top-1 and top-5 accuracy on the 50,000 validation images. Top-5 accuracy is the fraction of samples for which the true label appears among the top five predicted classes.

FID.

For our GAN experiments, the performance of each model is measured in terms of the Fréchet Inception Distance (FID) (Heusel et al., 2017b) computed from a total of 10,000 generated images.

27 Results

Unlike other works in the literature, we perform extensive hyperparameter tuning on $\epsilon$ (while also tuning the learning rate $\alpha$): following our observation that Adam behaves like SGD when $\epsilon$ is large, we should expect adaptive methods to perform comparably to SGD if hyperparameter tuning explores large values for $\epsilon$.

For all experiments we consider the following popular adaptive methods: Adam (Kingma and Ba, 2015), AMSGrad (Reddi et al., 2018), AdaBound (Luo et al., 2019), AdaShift (Zhou et al., 2019b), RAdam (Liu et al., 2020), AdaBelief (Zhuang et al., 2020), and AdamW (Loshchilov and Hutter, 2019). We also report results of AvaGrad, our newly-proposed adaptive method, along with its variant with decoupled weight decay (Loshchilov and Hutter, 2019), which we refer to as AvaGradW.

27.1 Improving Performance

CIFAR.

We train a Wide ResNet-28-4 (Zagoruyko and Komodakis, 2016) on the CIFAR dataset (Krizhevsky, 2009), which consists of 60,000 RGB images with $32\times 32$ pixels, and comes with a standard train/test split of 50,000 and 10,000 images. Following Zagoruyko and Komodakis (2016), we normalize images prior to training. We augment the training data with horizontal flips and by sampling $32\times 32$ random crops after applying a $4$-pixel padding to the images.

The leftmost columns of Table 15 present results: on CIFAR-10, SGD ($3.86\%$) is outperformed by Adam ($3.64\%$) and AvaGrad ($3.80\%$), while on CIFAR-100 Adam ($18.96\%$), AMSGrad ($18.97\%$), AdaShift ($18.88\%$), AvaGrad ($18.76\%$), and AvaGradW ($19.04\%$) all outperform SGD ($19.05\%$). These results disprove the conventional wisdom that adaptive methods are not suited for computer vision tasks such as image classification. While tuning $\epsilon$, a step typically overlooked or skipped altogether in practice, suffices for adaptive methods to outperform SGD (and hence can be a confounding factor in comparative studies), our results also suggest that adaptive methods might require large compute budgets for tuning to perform optimally on some tasks.

ImageNet.

To further validate that adaptive methods can indeed outperform SGD in settings where they have not been historically successful, we consider the challenging task of training a ResNet-50 He et al. (2016b) on the ImageNet dataset (Russakovsky et al., 2015).

SGD yields $24.01\%$ top-1 validation error, underperforming Adam ($23.45\%$), AMSGrad ($23.46\%$), RAdam ($23.60\%$), AvaGrad ($23.58\%$) and AvaGradW ($23.49\%$), i.e., 5 out of the 8 adaptive methods evaluated on this task. We were unable to train with AdaShift due to memory constraints: since it keeps a history of past gradients, our GPUs ran out of memory even with a reduced batch size of $128$, meaning that circumventing the issue with gradient accumulation would result in considerably longer training time.

The third column of Table 15 summarizes the results. In contrast to numerous papers that surpassed the state-of-the-art on ImageNet by training networks with SGD (Simonyan and Zisserman, 2015; Szegedy et al., 2015; He et al., 2016a, b; Zagoruyko and Komodakis, 2016; Xie et al., 2017), our results show that adaptive methods can yield superior results in terms of generalization performance as long as $\epsilon$ is appropriately chosen. Most strikingly, Adam outperforms AdaBound, RAdam, and AdaBelief: sophisticated methods whose motivation lies in improving the performance of adaptive methods.

Language Modeling.

We now consider a task where state-of-the-art results are achieved by adaptive methods with small values for $\epsilon$ and where SGD has little success: character-level language modeling with LSTMs (Hochreiter and Schmidhuber, 1997) on the Penn Treebank dataset (Marcus et al., 1994; Mikolov et al., 2010). We adopt the 3-layer LSTM (Hochreiter and Schmidhuber, 1997) model from Merity et al. (2018) with 300 hidden units per LSTM layer.

Results in Table 15 show that only AvaGrad and AvaGradW outperform Adam, achieving test BPCs of $1.179$ and $1.175$ compared to $1.182$. Combined with the previous results, we validate that, depending on the underlying task, adaptive methods might require vastly different values for $\epsilon$ to perform optimally, but, given enough tuning, are indeed capable of offering best overall results across domains.

We also observe that AdaBound, RAdam, and AdaBelief all visibly underperform Adam in this setting where adaptivity (small $\epsilon$) is advantageous, even given extensive hyperparameter tuning. RAdam, and more noticeably AdaBound, perform poorly in this task. We hypothesize that this is result of RAdam incorporating learning rate warmup, which is not typically employed when training LSTMs, and AdaBound’s adoption of SGD-like dynamics early in training (Savarese, 2019).

Generative Adversarial Networks.

Finally, we consider a task where adaptivity is not only advantageous, but often seen as necessary for successful training: generative modeling with GANs. We train a Geometric GAN (Lim and Ye, 2017), i.e., a DCGAN model (Radford et al., 2016) with the hinge loss, on the CIFAR-10 dataset to perform image generation. We do not apply gradient penalties.

Results are summarized in Table 15, showing that AvaGrad offers a significant improvement in terms of FID over all other methods, achieving an improvement of 7.7 FID over Adam (35.3 against 43.0). Note that the performance achieved by Adam matches other sources333github.com/POSTECH-CVLab/PyTorch-StudioGAN (Kang and Park, 2020), and Adam performed best with $\alpha=0.0002,\epsilon=10^{-6}$ in our experiments, closely matching the commonly-adopted values in the literature.

27.2 Hyperparameter Separability

The results in the previous section establish the importance of optimizing $\epsilon$ when using adaptive methods, and how not tuning $\epsilon$ can be a confounding factor when comparing different adaptive optimizers.

A key obstacle to proper tuning of $\epsilon$ is its interaction with the learning rate $\alpha$: as discussed in Section 25.2, ‘emulating’ SGD with a learning rate $\gamma$ can be done by setting $\alpha=\gamma\epsilon$ in Adam and then increasing $\epsilon$: once its value is large enough (compared to $v_{t}$), scaling up $\epsilon$ any further will not affect Adam’s behavior as long as $\alpha$ is scaled up by the same multiplicative factor. Conversely, when $\epsilon$ is small (compared to components of $v_{t}$), we have that $\sqrt{v_{t}}+\epsilon\approx\sqrt{v_{t}}$, hence decreasing $\epsilon$ even further will not affect the optimization dynamics as long as $\alpha$ remains fixed.

This suggests the existence of two distinct regimes for Adam (and other adaptive methods): an adaptive regime, when $\epsilon$ is small and there is no interaction between $\alpha$ and $\epsilon$, and a non-adaptive regime, when $\epsilon$ is large and the learning rate $\alpha$ must scale linearly with $\epsilon$ to preserve the optimization dynamics. The exact phase transition is governed by $v_{t}$ i.e., the second moments of the gradients, which depends not only on the task but also on the model.

By normalizing the parameter-wise learning rates $\eta_{t}$ at each iteration, AvaGrad guarantees that the magnitude of the effective learning rates is independent of $\epsilon$, essentially decoupling it from $\alpha$. With AvaGrad, $\alpha$ governs optimization dynamics in both regimes: when $\epsilon$ is small, changing its value has negligible impact on $\eta_{t}$ and $\|\eta_{t}\|$, hence the updates will be the same, while in the non-adaptive regime we have that $\eta_{t}\approx[\frac{1}{\epsilon},\frac{1}{\epsilon},\dots]$ and $\|\eta_{t}/\sqrt{d}\|_{2}\approx\frac{1}{\epsilon}$, hence normalizing $\eta_{t}$ yields an all-ones vector regardless of $\epsilon$ (as long as it remains large enough compared to all components of $v_{t}$).

Figures 34 and 35 show the performance of a Wide ResNet 28-4 on CIFAR-10 when trained with Adam and AvaGrad, for different $(\alpha,\epsilon)$ configurations i.e., the grid search employed for CIFAR, described in Section 26.3. For Adam, the non-adaptive regime is indeed characterized by a linear relation between $\alpha$ and $\epsilon$, while its performance in the adaptive regime depends mostly on $\alpha$ alone. AvaGrad offers decoupling between the two parameters, with $\alpha$ precisely characterizing the non-adaptive regime (i.e., the performance is independent of $\epsilon$) while almost fully describing the adaptive regime as well, except for regions close to the phase transition. For each of the $21$ different values of $\epsilon$, AvaGrad performed best with $\alpha=1.0$.

27.3 Hyperparameter Optimization

To assess our hypothesis that AvaGrad offers hyperparameter decoupling, which enables $\alpha$ and $\epsilon$ to be tuned independently via two line-search procedures instead of a grid search, we compare tuning costs of Adam and AvaGrad with prominent hyperparameter optimization methods such as Parzen Trees and CMA-ES. We also consider Gradientless Descent (GLD) (Golovin et al., 2020), a powerful zeroth-order method.

We frame the task of tuning $\alpha$ and $\epsilon$ as a 2D optimization problem with a $21\times 21$ discrete domain representing all $(\alpha,\epsilon)$ configurations for CIFAR discussed in Section 26.3, with the minimization objective being the error of a Wide ResNet-28-4 on CIFAR-10 when trained with the corresponding $(\alpha,\epsilon)$ values.

Figure 38 shows the number of iterations required by different hyperparameter optimizers to achieve $0.5\%$ suboptimality i.e., an error at most $0.5\%$ higher than the lowest achieved in the grid. AvaGrad is significantly cheaper to tune than Adam, regardless of the adopted tuning algorithm, including random search – showing that AvaGrad is able to perform well with a wider range of hyperparameter values.

We also consider a variant of GLD where descent steps on $\alpha$ and $\epsilon$ are performed separately in an alternating manner, akin to coordinate descent (Larochelle et al., 2007; Nesterov, 2012). This variant, which we denote by CGLD, is in principle well-suited for problems where variables have independent contributions to the objective, as is approximately the case for AvaGrad. Results are given in Figure 39: AvaGrad achieves less than $1\%$ suboptimality in 13 iterations when tuned with CGLD, while Adam requires $74$ with GLD. As expected, coordinate-wise updates result in considerably faster tuning for AvaGrad.

28 Analysis

28.1 Convergence

Lastly, we demonstrate our convergence results in Theorems 6.2 and 6.3 experimentally by employing Adam, AMSGrad, Adam with a 1-step delay (Delayed Adam), and Adam with $\epsilon_{t}=\sqrt{t^{3}}$, on a synthetic problem with the same form as the one used in the proof of Theorem 6.1:

[TABLE]

where f(w)\coloneqq~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{f_{s}(w)}\right].

This problem admits a stationary point $w^{\star}\approx 0.5$, and satisfies Theorem 6.2 for $\beta_{1}=0,\beta_{2}=0.99,\epsilon=10^{-8}$. Figure 40 presents $\frac{1}{t}\sum_{t^{\prime}=1}^{t}\left\lVert{\nabla f(w_{t^{\prime}})}\right\rVert^{2}$ during training, and shows that Adam fails to converge (Theorem 6.1), while both Delayed Adam and dynamic Adam converge successfully (Theorems 6.3 and 6.2). We attribute the faster convergence of Delayed Adam to the lack of constraints on the parameter-wise learning rates.

29 Discussion

29.1 Contributions

This chapter makes several key contributions:

• •

We show that Adam can provably converge for non-convex problems given a proper tuning of its adaptability parameter $\epsilon$. We address the apparent contradiction with Reddi et al. (2018), providing new insights on the role of $\epsilon$ in terms of convergence and performance of adaptive methods.

• •

Extensive experiments show that Adam can outperform SGD in tasks where adaptive methods have found little success. As suggested by our theoretical results, tuning $\epsilon$ is key to achieving optimal results with adaptive methods.

• •

We propose AvaGrad, a theoretically-motivated adaptive method that decouples the learning rate $\alpha$ and the adaptability parameter $\epsilon$. Quantifying the hyperparameter tuning cost using a zeroth-order method, we observe that AvaGrad is significantly cheaper to tune than Adam. Matching the generalization accuracy of SGD and other adaptive methods across tasks and domains, AvaGrad offers performance dominance given low tuning budgets.

29.2 Research Directions

Our analysis and empirical results suggest several promising directions for future research. Further investigating optimizer design with a focus on reducing or simplifying hyperparameter tuning costs, for example via adaptive schedules or meta-learned strategies, could further decrease the computational costs of finding optimal configurations for adaptive methods. Another direction is to analyze the generalization properties of adaptive methods and SGD. This could lead to a better understanding of how adaptivity affects generalization gaps, and how to best control it during training in order to balance training speed and final generalization performance.

29.3 Impact

Silva and Rodriguez (2023) propose a method to directly estimate the optimal value for $\epsilon$ and hence control an optimizer’s adaptivity by inspecting gradient statistics during training. Their approach circumvents the need to design a hand-crafted schedule for $\epsilon_{t}$, and balances training speed and final generalization performance dynamically and in a task-dependent fashion.

30 Proofs

31 Full Statement and Proof of Theorem 6.1

Theorem**.**

For any $\epsilon\geq 0$ and constant $\beta_{2,t}=\beta_{2}\in[0,1)$, there is a stochastic optimization problem for which Adam does not converge to a stationary point.

Proof.

Consider the following stochastic optimization problem:

[TABLE]

where $\delta$ is a positive constant to be specified later, and $C>\frac{1-p}{p}>1+\frac{\epsilon}{w_{1}\sqrt{1-\beta_{2}}}$ is another constant that can depend on $\delta,\beta_{2}$ and $\epsilon$, and will also be determined later. Note that $\nabla f(w)=pCw-(1-p)$, and $f$ is minimized at $w^{\star}=\frac{1-p}{Cp}=\frac{C-\delta}{C(1+\delta)}$.

The proof follows closely from Reddi et al. (2018). We assume w.l.o.g. that $\beta_{1}=0$. We first consider the difference between two consecutive iterates computed by Adam with a constant learning rate $\alpha$:

[TABLE]

and then we proceed to analyze the expected change in iterates divided by the learning rate. First, note that with probability $p$ we have $g_{t}=\nabla(C\frac{w_{t}^{2}}{2})=Cw_{t}$, and while $g_{t}=\nabla(-w)=-1$ with probability $1-p$. Therefore, we have

[TABLE]

where the expectation is over all the randomness in the algorithm up to time $t$, as all expectations to follow in the proof. We will proceed by computing lower bounds for the terms $T_{1}$ and $T_{2}$ above. Note that $T_{1}=0$ for $w_{t}=0$, while for $w_{t}>0$ we can bound $T_{1}$ by

[TABLE]

Combining the cases $w_{t}=0$ and $w_{t}>0$ (note that the feasible region is $w\in[0,1]$), we have that, generally, $T_{1}\geq\min(0,\frac{-1}{\sqrt{1-\beta_{2}}})=\frac{-1}{\sqrt{1-\beta_{2}}}$.

Next, we bound the expected value of $T_{2}$ using Jensen’s inequality coupled with the convexity of $x^{-1/2}$ as

[TABLE]

Let us consider ~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{v_{t-1}}\right] now. Note that

[TABLE]

where we used the fact that $v_{0}=0$ (i.e. the second-moment estimate is initialized as zero).

Taking the expectation of the above expression for $v_{t-1}$, we get

[TABLE]

where we can use the fact that $w_{t}\in[0,1]$, so $w_{t}^{2}\leq 1$ to get

[TABLE]

where $\sum_{i=0}^{t-2}\left(\beta_{2}^{i}-\beta_{2}^{i+1}\right)=1-\beta_{2}^{t-1}$ follows from the fact that the sum telescopes.

Plugging the above bound in (75) yields

[TABLE]

Combining the bounds for $T_{1}$ and $T_{2}$ in (73) gets us that

[TABLE]

Now, recall that $w^{\star}=\frac{C-\delta}{C(1+\delta)}$, so for $C$ sufficiently large in comparison to $\delta$ we get $w^{\star}\approx\frac{1}{1+\delta}$. On the other hand, the above quantity can be made non-negative for large enough $C$, so ~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{w_{t}}\right]\geq~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{w_{t-1}}\right]\geq\dots\geq w_{1}. In other words, Adam will, in expectation, update the iterates towards $w=1$ even though the stationary point is $w^{*}\approx\frac{1}{1+\delta}$ and we have $\left\lVert{\nabla f(1)}\right\rVert^{2}=\delta$ at $w=1$. Setting $\delta=1$, for example, implies that \lim_{T\to\infty}\frac{1}{T}\sum_{t=1}^{T}~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{\left\lVert{\nabla f(w_{t})}\right\rVert^{2}}\right]=1, and hence Adam presents nonconvergence in terms of stationarity. To see that $w=1$ is not a stationary point due to the feasibility constraints, check that $\nabla f(1)=1>0$: that is, the negative gradient points towards the feasible region. ∎

32 Technical Lemmas

This section presents intermediate results that are used in the proofs given in the next sections.

For simplicity we adopt the following notation for all following results:

[TABLE]

where $\eta_{t}\in\mathbb{R}^{d}$ denotes the parameter-wise learning rates computed at iteration $t$ (the method being considered and consequently the exact expression for $\eta_{t}$ will be specified in each result).

For the following Lemmas we rely extensively on the assumption that $\left\lVert{\nabla f_{s}(w)}\right\rVert_{\infty}\leq G_{2}$ for some constant $G_{2}$, and also that this assumption implies that there exists $G_{2}$ such that $\left\lVert{\nabla f_{s}(w)}\right\rVert\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$, which can be seen by noting that

[TABLE]

hence such constant $G_{2}$ must exist as any $G_{2}\geq\sqrt{d}\cdot G_{2}$ satisfies $\left\lVert{\nabla f_{s}(w)}\right\rVert\leq G_{2}$.

Lemma 6.1**.**

Assume that there exists a constant $G_{2}$ such that $\left\lVert{\nabla f_{s}(w)}\right\rVert_{\infty}\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$, and let $G_{2}$ be a constant such that $\left\lVert{\nabla f_{s}(w)}\right\rVert\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$. Moreover, assume that $\beta_{1,t}\in[0,1)$ for all $t\in\mathbb{N}$.

Let $m_{t}\in\mathbb{R}^{d}$ be given by

[TABLE]

where $\beta_{1,t}\in[0,1)$ for all $t\in\mathbb{N}$.

Then, we have

[TABLE]

for all $t\in\mathbb{N}$ and all possible sample sequences $(s_{1},\dots,s_{t})\in\mathcal{S}^{t}$.

Proof.

Assume for the sake of contradiction that $\left\lVert{m_{t}}\right\rVert_{\infty}>G_{2}$ for some $t\in\mathbb{N}$ and some sequence of samples $(s_{1},\dots,s_{t})$. Moreover, assume w.l.o.g. that $\left\lVert{m_{t^{\prime}}}\right\rVert_{\infty}\leq G_{2}$ for all $t^{\prime}\in\{1,\dots,t-1\}$ and note that there is no loss of generality since $(m_{t^{\prime}})_{t^{\prime}=0}^{t}$ must indeed have a first element that satisfies $\left\lVert{m_{t^{\prime}}}\right\rVert_{\infty}>G_{2}$, which cannot be $m_{0}$ since we have $m_{0}=0$ by definition.

Then, we have that $m_{t,i}>G_{2}$ for some $i\in[d]$, but

[TABLE]

where we used $\beta_{1,t}\in[0,1)$ and the assumptions $\left\lVert{m_{t-1}}\right\rVert_{\infty}\leq G_{2}$ and $\left\lVert{g_{t}}\right\rVert_{\infty}\leq G_{2}$.

To show that $\left\lVert{m_{t}}\right\rVert\leq G_{2}$, note that if we assume $\left\lVert{m_{t}}\right\rVert>G_{2}$ and $\left\lVert{m_{t^{\prime}}}\right\rVert\leq G_{2}$ for all $t^{\prime}\in\{1,\dots,t-1\}$, we again get a contradiction since, by the triangle inequality,

[TABLE]

therefore it must indeed follow that $\left\lVert{m_{t}}\right\rVert\leq G_{2}$.

∎

Lemma 6.2**.**

Assume that there exists a constant $G_{2}$ such that $\left\lVert{\nabla f_{s}(w)}\right\rVert_{\infty}\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$, and let $G_{2}$ be a constant such that $\left\lVert{\nabla f_{s}(w)}\right\rVert\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$. Moreover, assume that $\beta_{2,t}\in[0,1)$ for all $t\in\mathbb{N}$.

Let $v_{t}\in\mathbb{R}^{d}$ be given by

[TABLE]

where $\beta_{2,t}\in[0,1)$ for all $t\in\mathbb{N}$.

Then, we have

[TABLE]

for all $t\in\mathbb{N}$ and all possible sample sequences $(s_{1},\dots,s_{t})\in\mathcal{S}^{t}$.

Proof.

The proof follows closely from the one of Lemma 6.1. Assume for the sake of contradiction that there exists $t\in\mathbb{N}$ and some sequence of samples $(s_{1},\dots,s_{t})$ such that $\left\lVert{v_{t}}\right\rVert_{\infty}>G_{2}^{2}$ and $\left\lVert{v_{t^{\prime}}}\right\rVert_{\infty}\leq G_{2}^{2}$ for all $t^{\prime}\in\{1,\dots,t-1\}$.

Then $v_{t,i}>G_{2}^{2}$ for some $i\in[d]$ but

[TABLE]

where we used $\beta_{2,t}\in[0,1)$ and the assumptions $\left\lVert{v_{t-1}}\right\rVert_{\infty}\leq G_{2}^{2}$ and $\left\lVert{g_{t}}\right\rVert_{\infty}\leq G_{2}$, which raises a contradiction and shows that indeed $\left\lVert{v_{t}}\right\rVert_{\infty}\leq G_{2}^{2}$.

For the $\ell_{2}$ case, assume that $\left\lVert{v_{t}}\right\rVert>G_{2}^{2}$ and $\left\lVert{v_{t^{\prime}}}\right\rVert\leq G_{2}^{2}$ for all $t^{\prime}\in\{1,\dots,t-1\}$, which yields

[TABLE]

where we used the assumption $\left\lVert{g_{t}}\right\rVert\leq G_{2}$ which also implies that

[TABLE]

Checking that (86) yields a contradiction completes the argument.

∎

Lemma 6.3**.**

Under the same assumptions of Lemma 6.1, we have

[TABLE]

for all $t,t^{\prime}\in\mathbb{N}$ and all possible sample sequences $(s_{1},\dots,s_{\max(t,t^{\prime})})$.

Proof.

By definition,

[TABLE]

hence invoking Lemma 6.1 and taking the square root yields $\left\lVert{m_{t^{\prime}}\odot\eta_{t}}\right\rVert\leq G_{2}\left\lVert{\eta_{t}}\right\rVert$.

Additionally, we have

[TABLE]

hence recalling that $\left\lVert{\eta_{t}}\right\rVert_{\infty}=H_{t,\infty}$ and by Lemma 6.1 we get $\left\lVert{m_{t^{\prime}}\odot\eta_{t}}\right\rVert\leq G_{2}H_{t,\infty}$.

Combining the two bounds completes the proof. ∎

Lemma 6.4**.**

Under the same assumptions of Lemma 6.1, we have

[TABLE]

for all $t\in\mathbb{N}$ and all possible sample sequences $(s_{1},\dots,s_{t})\in\mathcal{S}^{t}$.

Proof.

Using the definition of $m_{t}$, we have

[TABLE]

where we used Cauchy-Schwarz in the last step.

Next, by Jensen’s inequality and the fact that $\left\lVert{\cdot}\right\rVert$ is convex we have, for all $w\in\mathbb{R}^{d}$,

[TABLE]

Applying this bound in (92) yields the desired inequality.

∎

Lemma 6.5**.**

Assume that there exists a constant $G_{2}$ such that $\left\lVert{\nabla f_{s}(w)}\right\rVert_{\infty}\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$, and let $G_{2}$ be a constant such that $\left\lVert{\nabla f_{s}(w)}\right\rVert\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$. Moreover, assume that $\beta_{1,t}\in[0,1)$ and $\beta_{1,t}\leq\beta_{1,t-1}$ for all $t\in\mathbb{N}$.

If $\eta_{t}$ is independent of $s_{t}$ for all $t\in\mathbb{N}$, i.e. $P(\eta_{t}=\eta,s_{t}=s)=P(\eta_{t}=\eta)P(s_{t}=s)$ for all $\eta\in\mathbb{R}^{d},s\in\mathcal{S}$, then

[TABLE]

for all $t\in\mathbb{N}$ and all possible sample sequences $(s_{1},\dots,s_{t})\in\mathcal{S}^{t}$.

Proof.

From Lemma 6.4 we have that

[TABLE]

Then, taking the expectation over the draw of $s_{t}\in\mathcal{S}$ and recalling that $w_{t}$, and hence also $\nabla f(w_{t})$, is computed from $(s_{1},\dots,s_{t-1})$,

[TABLE]

Now, note that since we assume that $\eta_{t}$ is independent of $s_{t}$, we get

[TABLE]

and also

[TABLE]

Combining (98) and (97) into (96) yields

[TABLE]

Moreover, we have

[TABLE]

which, when applied to (99) yields

[TABLE]

where we also used that $\beta_{1,t}\in[0,1)$ and $L_{t,\infty}\geq 0$. Using the fact that $\beta_{1,t}\leq\beta_{1,t-1}\leq\beta_{1}$ for all $t\in\mathbb{N}$ and hence $1-\beta_{1,t}\geq 1-\beta_{1}$ yields the desired inequality.

∎

33 Proof of Theorem 6.3

We organize the proof as follows: we first prove an intermediate result (Lemma 6.6) and split the proof of the bounds in (67) and (68) in two, where the latter can be seen as a refinement of (67) given the additional assumption that $Z\coloneqq\sum_{t=1}^{T}\alpha_{t}\min_{i}\eta_{t,i}$ is independent of each $s_{t}$.

Throughout the proof we use the following notation for clarity:

[TABLE]

Lemma 6.6**.**

Assume that $f$ is $L$-smooth, lower-bounded by some $f^{*}$ (i.e. $f^{*}\leq f(w)$ for all $w\in\mathbb{R}^{d}$), and that there exists a constant $G_{2}$ such that $\left\lVert{\nabla f_{s}(w)}\right\rVert_{\infty}\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$, and let $G_{2}$ be a constant such that $\left\lVert{\nabla f_{s}(w)}\right\rVert\leq G_{2}$ for all $s\in\mathcal{S}$ and $w\in\mathbb{R}^{d}$.

Consider any optimization method that performs updates following

[TABLE]

where we further assume assume that for all $t\in\mathbb{N}$ we have $\alpha_{t}\geq 0$, $\beta_{1,t}=\frac{\beta_{1}}{\sqrt{t}}$ for some $\beta_{1}\in[0,1)$, and $\eta_{t,i}\geq 0$ for all $i\in[d]$.

If $\eta_{t}$ is independent of $s_{t}$ for all $t\in\mathbb{N}$, i.e. $P(\eta_{t}=\eta,s_{t}=s)=P(\eta_{t}=\eta)P(s_{t}=s)$ for all $\eta\in\mathbb{R}^{d},s\in\mathcal{S}$, then

[TABLE]

for all $T\in\mathbb{N}$ and all possible sample sequences $(s_{1},\dots,s_{T})\in\mathcal{S}^{T}$.

Proof.

We start from the assumption that $f$ is $L$-smooth, which yields

[TABLE]

Plugging the update expression $w_{t+1}=w_{t}-\alpha_{t}\cdot\eta_{t}\odot m_{t}$,

[TABLE]

Now, taking the expectation over the random sample $s_{t}\in\mathcal{S}$, we get

[TABLE]

where we used the fact that $w_{t}$ and $\alpha_{t}$ are not functions of of $s_{t}$ – in particular, recall that $w_{t}$ is deterministically computed from $(s_{1},\dots,s_{t-1})$.

Using the assumption that $\eta_{t}$ is independent of $s_{t}$ and applying Lemma 6.5, we get

[TABLE]

which can be re-arranged into

[TABLE]

where we used the assumption that $\beta_{1}\in[0,1)$, hence $1-\beta_{1}>0$ which was used to divide both sides of the inequality.

Now, summing over $t=1$ to $T$,

[TABLE]

which yields the desired result.

∎

33.1 Proof of the first guarantee (Equation 67)

Proof.

We start from the bound given in Lemma 6.6:

[TABLE]

Now, using Lemma 6.3 to upper bound both $\left\lVert{m_{t-1}\odot\eta_{t}}\right\rVert$ and $\left\lVert{m_{t}\odot\eta_{t}}\right\rVert$ by $G_{2}H_{t,\infty}$,

[TABLE]

where we used that ~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{s_{t}}^{}}~\left[{H_{t,\infty}^{2}}\right]=H_{t,\infty}^{2} since $H_{t,\infty}$ is deterministically computed from $\eta_{t}$, which in turn is independent of $s_{t}$.

Next, from the assumption in Theorem 6.3 that there are positive constants $L_{\infty}$ and $H_{\infty}$ such that $L_{\infty}\leq\eta_{t,i}\leq H_{\infty}$ for all $t\in\mathbb{N},i\in[d]$ and sample sequences $(s_{1},\dots,s_{t})$, it follows that

[TABLE]

for all $t\in\mathbb{N}$, therefore

[TABLE]

Dividing both sides by $L_{\infty}\geq 0$ and letting $\alpha_{t}=\alpha^{\prime}/\sqrt{T}$ yields

[TABLE]

and, rearranging and using the fact that

[TABLE]

which implies that $\sum_{t=1}^{T}\frac{\alpha^{\prime}}{\sqrt{T}}\beta_{1,t}\leq 2\alpha^{\prime}\beta_{1}$, we get

[TABLE]

Now, taking the expectation over the full sample sequence $(s_{1},\dots,s_{T})$ yields

[TABLE]

Note that, by telescoping sum,

[TABLE]

where the last step follows since $w_{1}$ (the parameters at initialization) is independent of the drawn samples, and also from the assumption that $f^{*}$ lower bounds $f$.

Combining the above with (116) and dividing both sides by $\alpha^{\prime}\cdot\sqrt{T}$,

[TABLE]

Finally, we will use Young’s inequality with $p=2$ and the conjugate exponent $q=2$, which states that $xy\leq\frac{x^{2}}{2}+\frac{y^{2}}{2}$ for any nonnegative numbers $x,y$.

In that context, let

[TABLE]

which yields

[TABLE]

and hence

[TABLE]

Plugging the above in (118) yields

[TABLE]

Verifying that the above is $\mathcal{O}\left(\frac{1}{L\sqrt{T}}\left(\frac{1}{\alpha^{\prime}}+\alpha^{\prime}H_{\infty}^{2}\right)\right)$ in terms of $T,\alpha^{\prime},L_{\infty}$ and $H_{\infty}$ finishes the proof.

∎

33.2 Proof of the second guarantee (Equation 68)

Proof.

As before, we start from Lemma 6.6, which states that

[TABLE]

We then invoke Lemma 6.3 to upper bound $\left\lVert{m_{t-1}\odot\eta_{t}}\right\rVert$ by $G_{2}H_{t,\infty}$ and $\left\lVert{m_{t}\odot\eta_{t}}\right\rVert$ by $G_{2}\left\lVert{\eta_{t}}\right\rVert^{2}$:

[TABLE]

Next, define the unormalized probability distribution $\tilde{p}(t)=\alpha_{t}L_{t,\infty}$, so that $p(t)=\tilde{p}(t)/Z$ with $Z=\sum_{t=1}^{T}\tilde{p}(t)=\sum_{t=1}^{T}\alpha_{t}L_{t,\infty}$ is a valid distribution over $t\in\{1,\dots T\}$. Dividing both sides by $Z$ yields

[TABLE]

Now, taking the conditional expectation over all samples $S$ given $Z$:

[TABLE]

where in the second step we used ~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{s_{t}}^{}}~\left[{\cdot}\right]|Z}\right]=~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{\cdot|Z}\right] which follows from the assumption that $p(Z|s_{t})=p(Z)$, and the third step follows from telescoping sum and the assumption that $f^{*}$ lower bounds $f$.

Then, taking the expectation over $Z$ and re-arranging:

[TABLE]

Setting $\beta_{1}=0$ for simplicity yields

[TABLE]

Now, let $\alpha_{t}=\alpha_{t}^{\prime}/\sqrt{T}$

[TABLE]

Now, recall that $Z=\sum_{t=1}^{T}\alpha_{t}L_{t,\infty}=\frac{1}{\sqrt{T}}\sum_{t=1}^{T}\alpha_{t}^{\prime}L_{t,\infty}$, hence

[TABLE]

Finally, checking that \sum_{t=1}^{T}p(t)\left\lVert{\nabla f(w_{t})}\right\rVert^{2}=~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{t\sim\mathcal{P}(t|S)}^{}}~\left[{\left\lVert{\nabla f(w_{t})}\right\rVert^{2}}\right]:

[TABLE]

Recalling that $L_{t,\infty}=\min_{i}\eta_{t,i}$ completes the proof. ∎

34 Full Statement and Proof of Theorem 6.2

We organize the formal statement and proof of Theorem 6.2 as follows: we first state a general convergence result for Adam which depends on the step-wise adaptivity parameter $\epsilon_{t}$ and the learning rates $\alpha_{t}$ in Theorem 6.2, and then present a Corollary that shows how a $\mathcal{O}(1/\sqrt{T})$ rate follows from such result (Corollary Corollary). This section proceeds the proof of Theorem 6.3 (Appendix 33) as the proof presented here is more easily seen as a small variant (although overall simpler) of the analysis given in the previous section. Steps which also appear in the proof of Theorem 6.3 are not necessarily described in full detail, hence the following arguments can be better understood with the previous section in context.

Throughout the proof we use the following notation for clarity:

[TABLE]

Theorem**.**

Assume that $f$ is smooth and $f_{s}$ has bounded gradients. If $\epsilon_{t}\geq\epsilon_{t-1}>0$ for all $t\in[T]$, then for the iterates $\{w_{1},\dots,w_{T}\}$ produced by Adam we have

[TABLE]

where $w_{t}$ is sampled from $p(t)\propto\frac{\alpha_{t}}{G_{2}+\epsilon_{t-1}}$.

Corollary**.**

Setting $\epsilon_{t}=\Theta(T^{p_{1}}t^{p_{2}})$ for any $p_{1},p_{2}>0$ such that $p_{1}+p_{2}\geq\frac{1}{2}$ (e.g. $\epsilon_{t}=\Theta(\sqrt{T}),\epsilon_{t}=\Theta(\sqrt[4]{Tt}),\epsilon_{t}=\Theta(\sqrt{t})$) and $\alpha_{t}=\Theta\left(\frac{\epsilon_{t}}{\sqrt{T}}\right)$ on Theorem 6.2 yields a bound of $\mathcal{O}(1/\sqrt{T})$ for Adam.

Proof.

Similarly to the proof of Theorem 6.3, we plug the update rule $w_{t+1}=w_{t}-\alpha_{t}\cdot\eta_{t}\odot m_{t}$ in

[TABLE]

yielding

[TABLE]

By Lemmas 6.3 and 6.4, we have

[TABLE]

Now, note that we can write

[TABLE]

therefore we have that

[TABLE]

We will proceed to bound $\left|\left\langle\nabla f(w_{t}),g_{t}\odot(\eta_{t}-\eta_{t-1})\right\rangle\right|$. By Cauchy-Schwarz we have

[TABLE]

and moreover

[TABLE]

therefore we get

[TABLE]

Using the fact that $\eta_{t-1}$ is independent of $s_{t}$ and that ~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{s_{t}}^{}}~\left[{g_{t}}\right]=\nabla f(w_{t}), taking expectation over $s_{t}$ yields

[TABLE]

where in the second step we used $\beta_{1,t}\leq\beta_{1}$ and

[TABLE]

Re-arranging,

[TABLE]

Next, we will bound $L_{t-1},H_{t},\left\lVert{\eta_{t}}\right\rVert$, and $\left\lVert{\eta_{t}-\eta_{t-1}}\right\rVert$. Recall that, for Adam, we have

[TABLE]

and since $v_{t,i}\leq G_{2}^{2}$, we also have that

[TABLE]

From the above it follows that

[TABLE]

and

[TABLE]

which also implies that $\left\lVert{\eta_{t}}\right\rVert\leq\frac{\sqrt{d}}{\epsilon_{t}}$.

As for $\left\lVert{\eta_{t}-\eta_{t-1}}\right\rVert$, check that

[TABLE]

where we used the assumption that $\epsilon_{t}\geq\epsilon_{t-1}$. The above implies that $\left\lVert{\eta_{t}-\eta_{t-1}}\right\rVert\leq\sqrt{d}\cdot\frac{G_{2}+\epsilon_{t}-\epsilon_{t-1}}{\epsilon_{t-1}^{2}}$.

Applying the bounds given above to (142) yields

[TABLE]

Next, define the unormalized probability distribution $\tilde{p}(t)=\frac{\alpha_{t}}{G_{2}+\epsilon_{t-1}}$, so that $p(t)=\tilde{p}(t)/Z$ with $Z=\sum_{t=1}^{T}\tilde{p}(t)=\sum_{t=1}^{T}\frac{\alpha_{t}}{G_{2}+\epsilon_{t-1}}$ is a valid distribution over $t\in\{1,\dots T\}$. Adopting this notation and dividing both sides by $Z(1-\beta_{1})$:

[TABLE]

Taking the expectation over all samples and summing over $t$ yields

[TABLE]

where we used the fact that \sum_{t=1}^{T}~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{f(w_{t})}\right]-~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{f(w_{t+1})}\right]=f(w_{1})-~\smashoperator[]{\mathop{\mathchoice{\vbox{\hbox{\large\mathbb{E}}}}{\vbox{\hbox{\mathbb{E}}}}{\mathbb{E}}{\mathbb{E}}}\displaylimits_{}^{}}~\left[{f(w_{T+1})}\right]\leq f(w_{1})-f^{*} by telescoping sum and where $f^{*}$ lower bounds $f$.

For simplicity, assume that $\beta_{1,t}=0$ (or, alternatively, let $\beta_{1,t}=\frac{\beta_{1}}{\sqrt{T}}$ and apply Young’s inequality as in the proof of Theorem 6.3). In this case, we get

[TABLE]

and recalling that $Z=\sum_{t=1}^{T}\frac{\alpha_{t}}{G_{2}+\epsilon_{t-1}}$ yields

[TABLE]

which completes the argument. ∎