Extreme Tensoring for Low-Memory Preconditioning

TL;DR

This paper introduces extreme tensoring, a memory-efficient method for adaptive preconditioning in large-scale models, significantly reducing memory use without sacrificing performance.

Contribution

The paper proposes extreme tensoring, a novel approach that enables low-memory adaptive preconditioning applicable to arbitrary models, with theoretical guarantees and practical effectiveness.

Findings

Reduces optimizer memory overhead by 1000x on NLP models

Maintains model performance despite significant memory reduction

Provides regret and convergence guarantees for the proposed method

Abstract

State-of-the-art models are now trained with billions of parameters, reaching hardware limits in terms of memory consumption. This has created a recent demand for memory-efficient optimizers. To this end, we investigate the limits and performance tradeoffs of memory-efficient adaptively preconditioned gradient methods. We propose extreme tensoring for high-dimensional stochastic optimization, showing that an optimizer needs very little memory to benefit from adaptive preconditioning. Our technique applies to arbitrary models (not necessarily with tensor-shaped parameters), and is accompanied by regret and convergence guarantees, which shed light on the tradeoffs between preconditioner quality and expressivity. On a large-scale NLP model, we reduce the optimizer memory overhead by three orders of magnitude, without degrading performance.

Tables

Table 1. Table 1 : Performance and memory comparison between adaptive optimizers for GBW language modeling with a Transformer network.

Optimizer	Parameter count	Final ppl.
AdaGrad	$3.5\times {10}^7$	41.18
ET1	$1.2\times {10}^5$	39.84
ET2	$1.0\times {10}^4$	42.10
ET3	$5.0\times {10}^3$	45.19
ET$\infty$	90	47.94
SGD	1	49.80
Adam	$7.0\times {10}^7$	38.47
Adafactor	$1.2\times {10}^5$	38.86

Table 2. Table 2 : Performance comparison of memory-efficient optimizers on a model with doubled size (12-layer Transformer), so that total memory consumption is lower than that of AdaGrad/Adam on the smaller model. Final perplexities are given with the same running time allowance as the corresponding main experiment (middle column), as well as the same iteration count (500K steps; right column).

Optimizer	Final ppl. (time)	Final ppl. (iters)
ET1	39.25	36.23
ET2	43.81	40.04
ET3	44.70	40.45
ET$\infty$	42.95	41.68

Table 3. Table 3 : Tensor indices used for different levels of extreme tensoring for the ResNet-18 model on Cifar-10.

Parameter Shape	Shape (ET1)	Shape (ET2)	Shape (ET3)
$(64,3,3,3)$	$(64,3,9)$	$(8,8,3,9)$	$(8,8,3,9)$
$(64,64,3,3)$	$(64,64,9)$	$(8,8,8,8,9)$	$(8,8,8,8,9)$
$(128,64,3,3)$	$(128,64,9)$	$(8,16,8,8,9)$	$(8,4,4,8,8,9)$
$(128,128,3,3)$	$(128,128,9)$	$(8,16,8,16,9)$	$(8,4,4,8,4,4,9)$
$(256,128,3,3)$	$(256,128,9)$	$(16,16,8,16,9)$	$(4,4,4,4,8,4,4,9)$
$(256,256,3,3)$	$(256,256,9)$	$(16,16,16,16,9)$	$(4,4,4,4,4,4,4,4,9)$
$(512,256,3,3)$	$(512,256,9)$	$(32,16,16,16,9)$	$(8,4,4,4,4,4,4,4,9)$
$(512,512,3,3)$	$(512,512,9)$	$(32,16,32,16,9)$	$(8,4,4,4,8,4,4,4,9)$
$(128,64,1,1)$	$(128,64)$	$(16,8,8,8)$	$(4,4,8,8,8)$
$(256,128,1,1)$	$(256,128)$	$(16,16,16,8)$	$(4,4,4,4,4,4,8)$
$(512,128,1,1)$	$(512,128)$	$(32,16,16,8)$	$(8,4,4,4,4,4,8)$

Table 4. Table 4 : Performance and memory comparison between adaptive optimizers for Cifar-10 classification with a ResNet-18 network.

Optimizer	Parameter count	Final test error
Adam(${\beta }_1=0$)	$1.1\times {10}^7$	8.40
ET1	$2.3\times {10}^4$	7.22
ET2	$1.6\times {10}^4$	8.49
ET3	$1.5\times {10}^4$	8.52
ET$\infty$	62	8.57
SGD	1	9.27

Parameter	Parameter Shape	Shape (ET1)	Shape (ET2)	Shape (ET3)
$Q,K,V$, Position-wise Feed Forward	$(512,512)$	$(512,512)$	$(16,32,16,32)$	$(4,4,4,8,4,4,4,8)$
Embedding Weights	$(2000,512)$	$(2000,512)$	$(40,50,16,32)$	$(5,8,5,10,4,4,4,8)$
Layer Norm	$(512,)$	$(512,)$	$(16,32)$	$(4,4,4,8)$
Fully Connected Weights	$(512,2048)$	$(512,2048)$	$(16,32,32,64)$	$(4,4,4,8,4,8,8,8)$
Fully Connected Bias	$(2048,)$	$(2048,)$	$(32,64)$	$(4,8,8,8)$
Fully Connected Weights	$(2048,512)$	$(2048,512)$	$(32,64,16,32)$	$(4,8,8,8,4,4,4,8)$
Fully Connected Bias	$(512,)$	$(512,)$	$(16,32)$	$(4,4,4,8)$

Equations

$$\sum _{t=1}^T{f}_t(x_t)-\underset{x\in \mathcal{K}}{\min }\sum _{t=1}^T{f}_t(x).$$

$$\forall i\in [p],S^{(i)}[j]\leftarrow S^{(i)}[j]+\sum _{I:I_i=j}{\mathbf{g}}_t[I{]}^2$$

$${\mathbf{G}}_t^i[j,j]=\sum _{I:I_i=j}{\mathbf{g}}_t[I{]}^2$$

$$\sum _{t=1}^T{f}_t(x_t)-f_t(x^{\ast })\le D_{\infty }\sqrt{2\mathbf{Tr}(H_T)\mathbf{Tr}({\hat{H}}_T)},$$

$$x^{\ast }:=\underset{x}{\min }\sum _{t=1}^T{f}_t(x)$$

$$\sum _{t=1}^T{f}_t(x_t)-f_t(x^{\ast })\le \sqrt{2}{D}_{\infty }\mathbf{Tr}({\hat{H}}_T).$$

$$\mathrm{diag}(\epsilon \mathbf{I}+\sum _{s=1}^t{g}_s{g}_s^{\top }{)}^{1/2}⪯{\otimes }_{i=1}^p(\epsilon {\mathbf{I}}_{d_i}+\sum _{s=1}^t{\mathbf{G}}_s^i{)}^{1/2p}.$$

$$\mathrm{diag}(\epsilon \mathbf{I}$$

$$=(\epsilon +\sum _{s=1}^t{\mathbf{g}}_s[a_1,a_2,\cdots ,a_p{]}^2{)}^p$$

$$\le {\Pi }_{i=1}^p(\epsilon +\sum _{s=1}^t\sum _{I:I_i=a_i}{\mathbf{g}}_s[I{]}^2).$$

$$\mathrm{diag}(\epsilon \mathbf{I}$$

$$={\Pi }_{i=1}^p(\epsilon +\sum _{s=1}^t{\mathbf{G}}_s^i[a_i,a_i]{)}^{1/p}$$

$$={\Pi }_{i=1}^p(\epsilon {\mathbf{I}}_{d_i}+\sum _{s=1}^t{\mathbf{G}}_s^i)[a_i,a_i{]}^{1/p}$$

$$={\otimes }_{i=1}^p(\epsilon {\mathbf{I}}_{d_i}+\sum _{s=1}^t{\mathbf{G}}_s^i{)}^{1/p}[j,j].$$

$$\frac{1}{2\eta }\sum _{t=1}^T(\Vert x_t-x^{\ast }{\Vert }_{H_t}^2$$

$$+\frac{\eta }{2}\sum _{t=1}^T(\Vert g_t{\Vert }_{H_t}^{\ast }{)}^2.$$

$$x_{t+1}-x^{\ast }=x_t-x^{\ast }-\eta H_t^{-1}{g}_t,\text{and}$$

$$H_t(x_{t+1}-x^{\ast })=H_t(x_t-x^{\ast })-\eta g_t$$

$$(x_{t+1}-x^{\ast }{)}^{\top }{H}_t(x_{t+1}-x^{\ast })$$

$$=(x_t-x^{\ast }{)}^{\top }{H}_t(x_t-x^{\ast })$$

$$-2\eta (x_t-x^{\ast }{)}^{\top }{g}_t+{\eta }^2{g}_t^{\top }{H}_t^{-1}{g}_t.$$

$$g_t^{\top }(x_t-x^{\ast })=\frac{1}{2\eta }(\Vert x_t-x^{\ast }{\Vert }_{H_t}^2$$

$$+\frac{\eta }{2}(\Vert g_t{\Vert }_{H_t}^{\ast }{)}^2.$$

$$\sum _{t=1}^T{f}_t(x_t)-f_t(x^{\ast })\le \sum _{t=1}^T{g}_t\top (x_t-x^{\ast })$$

$$\le \frac{1}{2\eta }\sum _{t=1}^T(\Vert x_t-x^{\ast }{\Vert }_{H_t}^2-\Vert x_{t+1}-x^{\ast }{\Vert }_{H_t}^2)$$

$$+\frac{\eta }{2}\sum _{t=1}^T(\Vert g_t{\Vert }_{H_t}^{\ast }{)}^2$$

$$A_t={\mathrm{argmin}}_{A\in S^{+}}\{M_t\bullet A^{-1}+\Phi (A)\}$$

$$\sum _{t=1}^T(\Vert g_t{\Vert }_{A_t}^{\ast }{)}^2\le \sum _{t=1}^T(\Vert g_t{\Vert }_{A_T}^{\ast }{)}^2+\Phi (A_T)-\Phi (A_0).$$

$$\sum _{t=1}^T(\Vert x_t-x^{\ast }{\Vert }_{H_t}^2-\Vert x_{t+1}-x^{\ast }{\Vert }_{H_t}^2)$$

$$\le \sum _{t=2}^T(x_t-x^{\ast }{)}^T(H_t-H_{t-1})(x_t-x^{\ast })+\Vert x_1-x^{\ast }{\Vert }_{H_1}^2$$

$$\le D_{\infty }^2\sum _{t=2}^T\mathbf{Tr}(H_t-H_{t-1})+D_{\infty }^2\mathbf{Tr}(H_1)=D_{\infty }^2\mathbf{Tr}(H_T)$$

$$\Phi (A)=\mathbf{Tr}(A)+\epsilon \mathbf{Tr}(A^{-1}).$$

$${\mathrm{argmin}}_{A\in S^{+}}\{M_t\bullet A^{-1}+\Phi (A)\}$$

$$={\mathrm{argmin}}_{A\in S^{+}}\mathbf{Tr}({\hat{H}}_t^2{A}^{-1}+A)$$

$$={\hat{H}}_t$$

$$\sum _{t=1}^T(\Vert g_t{\Vert }_{{\hat{H}}_t}^{\ast }{)}^2\le \sum _{t=1}^T(\Vert g_t{\Vert }_{{\hat{H}}_T}^{\ast }{)}^2+\Phi ({\hat{H}}_T)-\Phi ({\hat{H}}_0)$$

$$\le \sum _{t=1}^T(\Vert g_t{\Vert }_{{\hat{H}}_T}^{\ast }{)}^2+\Phi ({\hat{H}}_T)$$

$$=\mathrm{diag}(\sum _{t=1}^T{g}_t{g}_t^{\top })\bullet {\hat{H}}_T^{-1}+\mathbf{Tr}({\hat{H}}_T)+\epsilon \mathbf{Tr}({\hat{H}}_T^{-1})$$

$$=\mathrm{diag}(\sum _{t=1}^T{g}_t{g}_t^{\top }+\epsilon \mathbf{I})\bullet {\hat{H}}_T^{-1}+\mathbf{Tr}({\hat{H}}_T)$$

Full text

1 Introduction

Among the most influential and important optimization techniques in machine learning are adaptive learning-rate methods, otherwise known as diagonal-matrix adaptive preconditioning. Essentially all of the most-commonly used incarnations of adaptive preconditioning (AdaGrad, Adam, RMSprop, Adadelta, etc.) accumulate second-moment estimators of each coordinate of the gradient, then scale the parameter updates by the square roots of these accumulators. These methods come with an overhead memory cost of storing these accumulators, thereby doubling the memory consumption. In the regime where model size encroaches upon the same order of magnitude as the total amount of RAM, a need has arisen to view memory as a limited resource in large-scale optimization.

We address the question of whether the benefits of adaptive preconditioning can be attained without significant memory overhead. To this end, we introduce extreme tensoring, a family of generic modifications to any second-moment-based adaptive optimizer. Our method uses a compressed preconditioner which takes the form of a tensor product of arbitrary order, with simple updates, without necessarily taking the view of requiring tensor-shaped parameters. In our regret analysis, we quantify how extreme tensoring competes provably with full-memory AdaGrad in the online convex optimization framework, with a multiplicative data-dependent constant that can be measured empirically.

In a large-scale language modeling setting, we demonstrate that an optimizer requires very little additional memory to benefit from adaptive preconditioning. Furthermore, the inherent flexibility of our method enables us to conduct, to the first of our knowledge, the first empirical study of the tradeoff between training convergence and memory in the optimizer.

1.1 Related work

The most widely-adopted form of adaptive preconditioning are second-moment-based: for example, AdaGrad [6], Adam [12], RMSprop [18], and Adadelta [21]. Some recent preconditioning methods are not based on second moments [3, 4, 2], and fall beyond our scope.

Tensor-factorized preconditioners in deep learning. [15, 9, 14] have investigated tensor-factorized preconditioners. These are presented in the view of restricted full-matrix preconditioning (vs. diagonal for us) of tensor parameters (vs. general-purpose for us). In parameter count regimes relevant to this paper, these full-matrix adaptive methods suffer from prohibitive time and memory overhead issues. The theoretical part of our work follows proof techniques seen in [8] and [9], although our diagonal restriction results in distinct updates and incomparable regret bounds.

Memory reduction in the optimizer. Perhaps the most closely related work to ours is Adafactor [17], an empirical work which achieves sublinear-memory adaptive regularization by restricting preconditioners on matrix-shaped gradients to “row” and “column” learning rates, with a similar update rule. Similar algorithms have appeared in prior work [7, 16]. As a special case of our regret analysis, we provide some theory for this line of work, while proposing a more general and versatile memory-reduction method.

Our contributions:

• •

We propose extreme tensoring as a modification to AdaGrad, Adam, etc. for reducing the overhead memory cost in adaptive preconditioning.

• •

Using the user-selectable degree of memory reduction, we conduct an empirical study of training convergence vs. preconditioner memory usage.

• •

We derive a regret bound for extreme-tensored AdaGrad. Strikingly, it competes with AdaGrad within a multiplicative constant, which we measure to be small in practice.

2 Preliminaries

2.1 Stochastic optimization and adaptive methods

We will state our algorithmic contribution in the usual framework of stochastic optimization of a differentiable function $f(\cdot)$, equipped with an unbiased stochastic gradient oracle $\widetilde{\nabla}f(\cdot)$. At each of $T$ iterations, the algorithm queries a stochastic gradient $g_{t}:=\widetilde{\nabla}f(x_{t})$. In practice, our target is the large-scale ERM setting, where $f$ is the population loss on training data, and $\widetilde{\nabla}\!f$ is a mini-batch stochastic gradient with respect to the model parameters.

However, since the introduction of AdaGrad [6], the standard analysis of adaptive regularization has been in the online convex optimization (OCO) framework (see, e.g. [8, 9]). In this language, we view the $x_{t}$ queried by the learning algorithm as a sequence of online decisions chosen from a convex set $\mathcal{K}$, and the $g_{t}$ as a sequence of gradients of adversarially chosen convex loss functions $f_{t}$. We are interested in minimizing the regret, defined as

[TABLE]

This is a generalization of stochastic convex optimization; for a broad survey, see [10]. A framework for reducing the stochastic non-convex setting to the online convex setting is introduced in [1], translating a sublinear regret bound to convergence to approximate stationary points.

2.2 Tensors and indexing conventions

We introduce some notation and terminology for clarity and convenience.

By $[n]$ we denote the index set $\{1,\ldots,n\}$. $\mathbf{I}_{d}$ and $\mathbf{0}_{d}$ refer to the $d\times d$ identity matrix and $d$-dimensional zero vector, respectively.

As is standard in optimization contexts, a tensor of order $p$ is an element of $\mathbb{R}^{d_{1}\times\ldots\times d_{p}}$: a $p$-dimensional table of real numbers, indexed by a $p$-tuple $I=(I_{1},\cdots I_{p})$ of integers, where $I_{i}\in[d_{i}]$. Our methods will require the user to specify a relabeling of gradient vectors, which we will call a tensor index:

Definition 2.1**.**

Let $d_{1},\ldots,d_{p}$ be positive integers whose product is $d$. A tensor index is a bijection $\mathcal{I}:[d]\rightarrow\bigtimes_{i=1}^{p}[d_{i}]$ between indices for $\mathbb{R}^{d}$ and $\mathbb{R}^{d_{1}\times\ldots\times d_{p}}$.

We will refer to the “reshape” conversion between vectors $x\in\mathbb{R}^{d}$ and tensors $\mathbf{x}\in\mathbb{R}^{d_{1}\times\ldots\times d_{p}}$ specified by the index bijection $\mathcal{I}$. For this, we will use the shorthand notation $\mathbf{x}:=\mathcal{I}(x)$ and $x:=\mathcal{I}^{-1}(\mathbf{x})$. Throughout this paper, we will use square brackets to refer to vector and tensor indices: for example, the previous definition can be restated as enforcing $x[i]=\mathbf{x}[\mathcal{I}(i)]$.

Although we do not need them to state the simple algorithm, it will be useful in the analysis to introduce a few other pieces of notation. We denote the tensor (or Kronecker) product of matrices $A,B$ by $A\otimes B$. Given a positive definite matrix $A\in{\mathbb{R}}^{d\times d}$, for any $x\in{\mathbb{R}}^{d}$, define the matrix norm $\|x\|_{A}:=\sqrt{x^{\top}Ax}$ and its dual $\|x\|_{A}^{*}:=\sqrt{x^{\top}A^{-1}x}$. For a square matrix $M$, $\mathrm{diag}(M)$ refers to the diagonal matrix of the same dimensions and diagonal entries as $M$.

3 Preconditioning by extreme tensoring

We begin by presenting our proposal for black-box memory reduction in adaptive preconditioning. We call this extreme tensoring, as it takes the view of restricting a high-dimensional preconditioner to an arbitrary-order tensor product.

The algorithm implicitly maintains a preconditioner which is a rank-one tensor product of the same dimension as a given tensor index. A second-moment accumulator is maintained for sums of squared gradient magnitudes across each $(p-1)$-dimensional tensor slice; the adaptive step size for each coordinate is the inverse square root of the geometric mean of its $p$ corresponding slice sums. The formal specification of the base algorithm (AdaGrad with extreme tensoring) is given in Algorithm 1.

We make a few important remarks:

• •

AdaGrad is a special case of Algorithm 1, with $p=1,d_{1}=d$. The analogues for Adam, RMSprop, Adadelta, etc. are obtained straightforwardly by decaying the accumulator ($S^{(i)}[j]\leftarrow\beta_{2}\cdot S^{(i)}[j]+\ldots$). Extreme tensoring is compatible with first-moment estimation (i.e. momentum), although the memory savings disappear. In the setting for our main empirical result, removing momentum did not degrade performance, corroborating the findings of [17].

• •

If the tensor dimensions $(d_{1},\ldots,d_{p})$ in the decomposition are close to equal, the memory overhead scales as $O(p\cdot d^{1/p})$.

• •

As is standard in matrix and tensor optimization methods [9, 17, 14], independent copies of Algorithm 1 can be run on each tensor-shaped parameter group; optimizer APIs in standard deep learning packages promote this convention. This can be viewed as maintaining a tensor sum of preconditioners, each of which is a $p$-wise tensor product.

• •

The accumulator update step can be implemented concisely and efficiently using re-indexing procedures (typically called reshape or view) in standard deep learning and numerical linear algebra packages.

Lemma 4.3 in the analysis shows that the per-coordinate learning rates are underestimates of those prescribed by AdaGrad. This interpretation is used in our proof, and serves as the basis of the empirical measurements in Section 5.3.

4 Regret analysis

In this section, we justify the choice of update rules for the compressed preconditioner using the regret-minimizing adaptive regularization framework introduced in the original analysis of AdaGrad [6]. Throughout the analysis, we will adopt the conventions of online convex optimization, as discussed in Section 2.1. This gives rise to an intuitively appealing and interpretable regret bound, which we discuss in this section and revisit in the empirical measurements of Section 5.3.

4.1 Statement and discussion of regret bound

First, we define and prove the main regret bound. As is standard in the regret analysis of diagonal AdaGrad (see [6]), this is most naturally stated with a diameter term on $x_{t}$: $D_{\infty}:=\max_{t,x^{*}}\mathopen{\|}x_{t}-x^{*}\mathclose{\|}_{\infty}$. This can be constrained using a projection onto an $\ell_{\infty}$ ball in the algorithm, but this is seldom seen in practice. It will also be helpful to define $\mathbf{G}_{t}^{i}$ to be the diagonal matrix with values

[TABLE]

on the diagonal.

Theorem 4.1**.**

Define $H_{T}=\otimes_{i=1}^{p}(\varepsilon\mathbf{I}_{d_{i}}+\sum_{t=1}^{T}\mathbf{G}_{t}^{i})^{1/2p}$, and $\hat{H}_{T}=\operatorname{diag}(\varepsilon\mathbf{I}+\sum_{t=1}^{T}g_{t}g_{t}^{\top})^{1/2}$. Then, there exists a choice of constant learning rate schedule $\eta_{1}=\ldots=\eta_{t}:=\eta$ and $\varepsilon>0$ such that the $\{x_{t}\}$ chosen by Algorithm 1 satisfy the regret bound

[TABLE]

where

[TABLE]

is the loss-minimizing decision in hindsight.

As a direct consequence, we recover the AdaGrad regret bound as a special case where $p=1$. Noting further that $H_{T}=\hat{H}_{T}$, we restate this well-known result in our notation, for clarity and comparisons:

Corollary 4.2**.**

In setting of Theorem 4.1, when $p=1$, the $\{x_{t}\}$ chosen by Algorithm 1 satisfy

[TABLE]

Thus, AdaGrad with extreme tensoring satisfies a regret bound at most $\sqrt{{\bf Tr}(H_{T})/{\bf Tr}(\hat{H}_{T})}$ times than that of AdaGrad. This quantity can be as large as $\Omega(\sqrt{d})$; this is the worst-case price of the dramatic memory savings in the regularizer. However, in the presence of sparsity, this ratio can be much smaller; we include a discussion and empirical measurements in Section 5.3.

4.2 Proofs

The derivation of the regret bound uses the proof framework introduced by [8]. Our first important lemma states that the regularizer in Algorithm 1 is a spectral (per-coordinate) upper bound for the diagonal AdaGrad preconditioner. In other words, this lemma establishes that the per-coordinate learning rates under extreme tensoring are underestimates of those dictated by AdaGrad.

Lemma 4.3**.**

Suppose $\mathbf{g}_{1},\mathbf{g}_{2},\cdots,\mathbf{g}_{T}$ are tensors of dimension $d_{1}\times\cdots\times d_{p}$, and let $g_{t}=\mathcal{I}^{-1}(\mathbf{g}_{t})$ for all $t$, where $\mathcal{I}$ is any tensor index whose image is $\bigtimes_{i=1}^{p}[d_{i}]$. Then for $t\in[T]$,

[TABLE]

Proof.

Let $d=d_{1}d_{2}\cdots d_{p}$. Let $j\in[d]$ and let $a_{1},\ldots,a_{p}$ be such that $\mathcal{I}(j)=[a_{1},a_{2},\cdots,a_{p}]$.

[TABLE]

Taking the $p$th root on both sides,

[TABLE]

Taking square roots of the above inequality yields the lemma. ∎

4.3 Regret bound

The following lemma bounds the regret in terms of the quadratic norms in the regularizer and its dual:

Lemma 4.4**.**

Denote by $H_{t}$ the $d$-by-$d$ diagonal matrix whose entries are $(\mathcal{I}^{-1}(\delta_{t}))^{-1}$. Take $\eta_{1}=\ldots=\eta_{t}:=\eta$ to be the constant learning rate, and let $x^{*}$ be the loss minimizing choice in hindsight. Then, the regret of Algorithm 1 is bounded by

[TABLE]

Proof.

By the definition of Algorithm 1, for any $x^{*}$,

[TABLE]

[TABLE]

Taking the inner product of the above vectors,

[TABLE]

Rearranging and dividing by $2\eta$, we have

[TABLE]

Using convexity of the loss functions and sum over $t$, we finally bound the regret as follows:

[TABLE]

∎

Next, we present a lemma that is later used to bound the second term in the regret.

Lemma 4.5**.**

[9]** Let $g_{1},g_{2},\cdots,g_{T}$ be a sequence of vectors, and let $M_{t}=\operatorname{diag}(\sum_{x=1}^{t}g_{s}g_{s}^{\top})$. Let $S^{+}$ denote the set of diagonal positive definite matrices. Given a function $\Phi$ over $S^{+}$, define

[TABLE]

and assume that the minimum is attained for all $t$. Then

[TABLE]

We proceed to prove Theorem 4.1.

Proof.

(Proof of Theorem 4.1) Recall the definition of $H_{t}=\otimes_{i=1}^{p}(\varepsilon\mathbf{I}_{d_{i}}+\sum_{s=1}^{t}\mathbf{G}_{s}^{i})^{1/2p}$, we bound the first term in Lemma 4.4 as follows,

[TABLE]

The last inequality is due to the fact that $H_{t-1}\preceq H_{t}$. Recall $\hat{H}_{t}=\operatorname{diag}(\varepsilon\mathbf{I}+\sum_{s=1}^{t}g_{s}g_{s}^{\top})^{1/2}$, and by Lemma 4.3, $\hat{H}_{t}\preceq H_{t}$. Now we use Lemma 4.5 with function

[TABLE]

Let $M_{t}=\operatorname{diag}(\sum_{s=1}^{t}g_{s}g_{s}^{\top})$ and let $S^{+}$ denote the set of diagonal positive definite matrices, we have

[TABLE]

The last equality can be derived by minimizing each diagonal entry of $H$ individually.

By Lemma 4.5,

[TABLE]

We can take the diagonal of $\sum_{t=1}^{T}g_{t}g_{t}^{\top}$ in the first equality since $\hat{H}_{T}^{-1}$ is a diagonal matrix as well.

We proceed to bound the second term in Lemma 4.4. Since $\hat{H}_{t}\preceq H_{t}$ and both $H_{t}$ and $\hat{H}_{t}$ are full-rank, $\hat{H}_{t}^{-1}\succeq H_{t}^{-1}$. Therefore

[TABLE]

Summing up the two terms and taking $\eta=D_{\infty}\frac{\sqrt{{\bf Tr}(H_{T})}}{\sqrt{2{\bf Tr}(\hat{H}_{T})}}$, we conclude that the regret of Algorithm 1 is bounded by

[TABLE]

∎

5 Experiments

In this section, we provide several empirical studies on extreme tensoring. Our main experiment interpolates between the memorylessness of SGD and the full memory consumption of AdaGrad on a large-scale language model; we additionally isolate the effects of preconditioner expressivity in a synthetic experiment of the same form, and provide a parallel CIFAR-10 experiment in the appendix.

To accompany the main experimental result, we provide empirical measurements of the competitive ratio in the regret bound, as well as a quick comparison in which the memory savings are used to train a larger model.

5.1 Memory-performance tradeoff in large-scale NLP

Our main empirical study focuses on large-scale language modeling with the Transformer architecture [20] on the Google Billion Words (GBW) dataset [5]. We use the pipeline from the open-source Tensor2Tensor package [19] for preprocessing the GBW dataset, and use the base Transformer architecture in the same repository as our base architecture. The decoder-only model has 6 identical layers with hidden dimension $d_{model}=512$, and feedforward dimension $d_{ff}=2048.$ In addition, the weights are shared between the embedding and softmax layers, and the model has a total of $\sim\!35$M parameters.

For our experiments, we use a learning rate schedule of $\eta_{t}=c\cdot\min(10^{-6}\cdot t,\frac{1}{\sqrt{t}})$, and $c$ is a hyperparameter we tune for each experiment. The learning rate schedule is the same as the one used in [17]: a linear warmup stage, followed by inverse square root decay. We train each model for 500K steps, with a max sequence length of 256 tokens, and a max number of 4096 tokens in a batch. Global learning rates are selected by hyperparameter search.

Except in our comparison with Adam, we do not use momentum in our extreme tensoring experiments. Momentum incurs an overhead memory cost linear in the model dimension. In addition, we empirically tested the benefit of exponentially decaying the second moment estimator ($\beta_{2}<1$ in the language of Adam and Adafactor). We found that in language modeling experiments, decaying the second moment estimator did not contribute to better performance; on the other hand, the vision experiments in the appendix do use this decay ($\beta_{2}=0.99$).

Extreme tensoring gives us a class of optimizers which interpolate smoothly between AdaGrad and SGD. Between these endpoints, we choose three levels of extreme tensoring (denoted by ET$\{1,2,3\}$), with tensor index dimensions fully specified in the appendix. Figure 4 records the training performance for these interpolating algorithms. We also provide training results for Adam (which consumes more memory for first-moment estimation) and Adafactor (similar to ET1 but with a different step size scaling) in Table 4, for completeness; however, these are not part of the interpolation study.

To provide an additional interpolating point, we include in the comparison a closely related algorithm, which selects a single learning rate per parameter group (e.g. embedding, bias, convolutional layer); thus, the preconditioner is a tensor sum of scalar multiples of the identity matrix. Each such scalar is chosen to be the inverse square root of the sum of squared $\ell_{2}$ norms of the parameter group over time; it is easily seen that this achieves the same regret as online gradient descent [22], so we include it as the least granular adaptive optimizer, and call it ET$\infty$.

5.2 Doubling the memory allowance

As an extension of the above comparison, we argue that the memory consumption freed up by choosing a compressed adaptive optimizer can be usefully reallocated to training a larger model. We double the number of layers of the Transformer network used in the previous section, keeping all embedding sizes the same; this results in a network with 56M parameters.

Results are shown in Table 2. Holding the memory consumption constant, we find that it pays off to use a larger model rather than an adaptive optimizer that stores all of the second-moment accumulators. Even holding the running time constant, the larger models are competitive with the fully-converged smaller ones.

5.3 Empirical measurements of the regret bound

An appealing part of our regret analysis is the interpretability of the trace quantities in Theorem 4.1. Table 2 shows a comparison of traces ${\bf Tr}(H_{T})$ and ${\bf Tr}(\hat{H}_{T})$ of the final regularizers in the language modeling experiment. Then, by Theorem 4.1 and Corollary 4.2, the upper bound for AdaGrad’s regret scales with the latter quantity, while that of extreme tensoring scales with the geometric mean of the two traces.

Intriguingly, the multiplicative gap between these two regret bounds, which depends on the loss function and training trajectory via the sequence of gradients, appears to be very small in practice. In the case of one-level extreme tensoring, we have $\sqrt{{\bf Tr}(H_{T})/{\bf Tr}(\hat{H}_{T})}\approx 5.7$.

5.4 Comparison on synthetic data

In this section, we exhibit a simple experiment with a convex optimization problem (logistic regression), in which there is a clear tradeoff between preconditioner quality and expressivity. We generate Gaussian data $x_{i}\in\mathbb{R}^{512}$ and a Gaussian matrix $W\in\mathbb{R}^{10\times 512}$. The covariance matrix of $\{x_{i}\}$ has high condition number ($\sim 10^{4}$). Labels are generated according to the log-linear model $\Pr[y_{i}=j]\propto\exp((Wx_{i})_{j})$. Then, the optimization problem in $W$ is to minimize the empirical negative log-probability under the same model. Our findings are robust with respect to the batch size; we use the full gradient on $10^{4}$ samples in our plots for clarity.

As in the large-scale experiment, we use successively deeper tensor factorizations of the preconditioner, along the feature dimension of the matrix $W$. For depths 1, 2, and 3, we choose tensor indices of dimensions $(10,512)$, $(10,16,32)$, and $(10,8,8,8)$, respectively. Global learning rates are tuned individually. Results are shown in Figure 3.

6 Conclusion

We have introduced extreme tensoring, a modification to any second-moment-based adaptive optimizer which drastically shrinks memory overhead. Our experiments characterize a performance-memory tradeoff in the optimizer, and demonstrate the possibility of negligible memory overhead without degrading convergence. Our regret analysis provides a competitive ratio with uncompressed adaptive methods, giving an additional empirical lens on data-dependent preconditioner quality.

Appendix A CIFAR-10 experiment

In this section, we evaluate the memory-performance trade-off of our proposed algorithm on the CIFAR-10 dataset [13]. Specifically, we compare the test accuracy of a ResNet-18 model [11] trained with SGD, Adam and 3 levels of extreme tensoring.

A.1 Setup

With each optimizer, the model is trained for 150 epochs with optimally tuned constant learning rate. To prevent a 2X memory overhead, no momentum is used for any of the optimizers (i.e. $\beta_{1}=0$ in Adam). We use batch size $128$, weight decay $5\times 10^{-4}$ for all the experiments in this section.

A.2 Tensor indices

We show our tensor decomposition scheme in the table below. Note that bias parameters are not shown in each layer in the table since are treated as vectors and thus not decomposed at all.

A.3 Results

In this section, we report the best test errors seen in the first 150 epoch along with the parameter count in the optimizer. A similar trend of trade-offs between performance and parameter count is observed.

Appendix B Language modeling experiment details

In this section, we provide more details for the main empirical result.

B.1 Tensor indices