L EARNING TO G ROW P RETRAINED M ODELS FOR E FFICIENT T RANSFORMER T RAINING
A BSTRACT
Scaling transformers has led to significant breakthroughs in many domains, leading to a paradigm in which larger versions of existing models are trained and released on a periodic basis.
New instances of such models are typically trained completely from scratch, despite the fact that they are often just scaled-up versions of their smaller counterparts.
How can we use the implicit knowledge in the parameters of smaller, extant models to enable faster training of newer, larger models?
This paper describes an approach for accelerating transformer training by learning to grow pretrained transformers, where we learn to linearly map the parameters of the smaller model to initialize the larger model.
For tractable learning, we factorize the linear transformation as a composition of (linear) widthand depth-growth operators, and further employ a Kronecker factorization of these growth operators to encode architectural knowledge.
Extensive experiments across both language and vision transformers demonstrate that our learned Linear Growth Operator (LiGO) can save up to 50% computational cost of training from scratch, while also consistently outperforming strong baselines that also reuse smaller pretrained models to initialize larger models.
I NTRODUCTION
The transformer architecture (Vaswani et al., 2017) has emerged as a general purpose architecture for modeling many structured domains (Devlin et al., 2019; Brown et al., 2020; Rives et al., 2021;
Dosovitskiy et al., 2021; Touvron et al., 2021a).
Perhaps more so than other architectures, the transformer empirically seems to have inductive biases that make it especially amenable to scaling (Rosenfeld et al., 2019; Kaplan et al., 2020), which has led to a paradigm in which larger versions of smaller, existing models are trained and released on a periodic basis (e.g., the GPT lineage of models (Radford et al., 2018; 2019; Brown et al., 2020)).
New instances of such models are typically trained completely from scratch, despite the fact that they are often scaled-up versions of their smaller counterparts.
Given the compute required to train even the smaller models, we argue that training each model from scratch is wasteful, and that prior knowledge implicit in the parameters of smaller pretrained models should be leveraged to enable faster training of larger models.
One approach to this problem is through the lens of model growth , wherein a smaller model’s pretrained parameters are used to initialize a subset of the larger model’s parameters.
While earlier works generally froze the parameters initialized from the pretrained model and only trained the new (randomly initialized) parameters (Fahlman & Lebiere, 1989; Fahlman, 1990; Gutstein et al., 2008), subsequent work has shown that copying a subset of the pretrained parameters to initialize the new parameters and then finetuning the entire network significantly accelerates training and sometimes even leads to better performance (Chen et al., 2015).
When applied to modern transformers, these mechanisms roughly translate to a depth-expansion operator in which pretrained models are stacked (or combined with identity layers) to initialize deeper transformers (Gong et al., 2019;
Yang et al., 2020), and a width-expansion operator in which the smaller model’s
matrices are copied to initialize the larger model’s matrices (e.g., in block-diagonal fashion)
(Chen et al., 2021; Gu et al., 2020).
Project page: https://vita-group.github.io/LiGO/
Noting the empirical effectiveness of such recipes, we observe that existing mechanisms generally do not have a learning component (e.g., randomly copying over neurons for width-expansion or stacking consecutive layers for depth-expansion).
This paper instead proposes an efficient, datadriven approach for learning to grow transformers.
In particular, our approach frames the problem of initializing the larger model’s parameters as learning a linear mapping from the smaller model’s parameters, i.e., Θ ( large ) =
M Θ ( small ) where Θ ( small ) and Θ ( large ) are the vectorized parameters of the small/large models.
Due to the high dimensionality of the parameters, this mapping is completely intractable to learn without any restrictions on M .
We thus factorize the linear mapping to be a composition of sparse width- and depth-expansion operators, M = L depth R width , where both width and depth matrices are further factorized to be a Kronecker product of smaller matrices that express architectural knowledge (e.g., through grouping parameters by layers and neurons).
We show that our growth operators can represent existing approaches such as layer-stacking and neuron-copying as special cases.
We find that with a small amount of learning on M (e.g.,gradient steps) to initialize the larger model, we can significantly accelerate training of both vision and language transformers.
Figure 1 illustrates our approach.
We apply our learned linear growth operator (LiGO) to popular families of models—BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), GPT2 (Radford et al., 2019), and ViT (Dosovitskiy et al., 2021; Touvron et al., 2021a;b)—and find that LiGO can consistently improve transformer training efficiency over the traditional way of training from scratch across domains and model sizes.
For instance, LiGO saves 44 .
7% and 22 .
5% FLOPs for training BERT-Base and GPT2-Medium from scratch by reusing pretrained smaller models that are half as big.
Similarly, for vision transformers, when using DeiT-S (Touvron et al., 2021a) for initialization, LiGO yields 55% savings in FLOPs with no performance drop on ImageNet (Deng et al., 2009).
These FLOPs savings directly translate to similar wall clock savings.
We further find that models trained using LiGO achieve similar performance to the trained-from-scratch baselines when transferred to downstream tasks.
R ELATED W ORK
Efficient training.
Efficient training of transformers has been studied from multiple perspectives.
Some methods that are orthogonal to our work include mixed precision training (Shoeybi et al., 2019), large batch optimization (You et al., 2019), distributed training (Huang et al., 2019), and dropping layers (Zhang & He, 2020) or tokens (Hou et al., 2022).
Knowledge inheritance (Qin et al., 2021) explores knowledge distillation during pretraining to efficiently learn larger transformers.
Progressive training, which first trains a small transformer with few layers and then gradually expands by stacking layers, has also been applied to accelerate transformer training (Gong et al., 2019;
Yang et al., 2020; Li et al., 2022;
Shen et al., 2022).
Net2Net Chen et al.
(2015) uses functionpreserving transformations to grow width by copying neurons and depth by using identity layers.
Recently, bert2BERT (Chen et al., 2021) extends Net2Net to transformers.
In contrast to these approaches, our approach learns to (linearly) transform the parameters of a smaller model to initialize a larger model.
While there is a line of work on learning to grow neural networks in a data-driven way, these methods are in general difficult to apply to modern-scale transformers since they (for example) involve growing a single neuron at a time or employ expensive optimization/search procedures (Wei et al., 2016;
Cai et al., 2018; Wu et al., 2019; 2021; Evci et al., 2022).
Network initialization.
Our work is also related to work on neural network initialization.
Existing works include controlling the norm of the parameters (Mishkin & Matas, 2015; Kilcher et al., 2018; Dai et al., 2019; Wu et al., 2019; Glorot & Bengio, 2010) or replacing the normalization layers (Brock et al., 2021;
Zhang et al., 2019; Huang et al., 2020).
MetaInit (Dauphin & Schoenholz, 2019) proposes an automatic method that optimizes the norms of weight tensors to minimize the gradient quotient on minibatches of random Gaussian samples.
GradInit (Zhu et al., 2021) learns to initialize larger networks by adjusting norm of each layer.
Our work focuses on using smaller pretrained transformers to better initialize larger transformers, which remains an understudied problem.
Structured matrices.
Finally, our work is also related to structured matrices which are typically used to replace dense weight matrices for reducing training and inference computation cost.
Examples include sparse and low rank matrices (Chiu et al., 2021; Han et al., 2015), Chebyshev matrices (Tang et al., 2019), Toeplitz matrices (Sindhwani et al., 2015), Kronecker-product matrices (Zhang et al., 2015), and butterfly matrices (Dao et al., 2019).
A unified framework to learn a broad family of structured matrices is presented in Sindhwani et al.
Dao et al.
(2022) propose Monarch matrices, which inherit the expressiveness of butterfly matrices and achieve reasonable accuracy-efficiency tradeoffs in many applications.
While our approach is inspired by these works, we propose to grow pretrained models by learning structured sparse linear operators with Kronecker factorization, which to our knowledge has not been explored in the literature.
P ROPOSED A PPROACH
Notation.
We denote the parameters of a neural network with L layers and D dimensions as Θ L,D
=
[ W· · · W L ] ⊤ ∈ R LD × D , where W l ∈ R D
× D denotes the weights for the l -th layer.
2 With slight abuse of notation, we denote the vectorization of Θ L,D as vec( Θ L,D ) ⊤ = (cid:2) vec( W 1 ) ⊤ · · · vec( W L ) ⊤ (cid:3) .
3 Our goal is to re-use the parameters
Θ =
Θ L 1 ,D 1 from a pretrained smaller model to initialize a large model Θ ( new ) =
Θ L 2 ,D 2 through a model growth operator
M : R L 1 D 1 × D 1 → R L 2 D 2 × D 2 that maps the weights of the smaller network to the weights of the larger one, i.e., Θ ( new ) =
M ( Θ ) where L 1 <
L 2 and D 1 < D 2 .
After model growth, we adopt Θ ( new ) as the initialization of the large model and train it using standard recipes.
3. E XISTING G ROWTH O PERATORS
Existing works have separately established model growth operators for depth ( L 1 < L 2 , D 1 = D 2 ) and width ( L 1 =
L 2 , D 1 < D 2 ).
We summarize these methods below.
Depth expansion.
StackBERT (Gong et al., 2019) proposes to duplicate the smaller model to double the depth, based on the observation that upper layers share similar functionality with the lower layers.
In contrast, interpolation-based depth expansion methods (Chang et al., 2017; Dong et al., 2020) interleave every layer to form a deeper model, which can be roughly interpreted as simulating a finer-grained solution to the original dynamical system from a neural ODE perspective (Chen et al., 2018).
Letting L 2 = kL 1 , the two methods’ growth operators can be formulated as:
[Equation]
Width expansion.
Net2Net (Chen et al., 2015) expands the width of neural networks by randomly copying neurons while preserving output values via normalization.
This can be seen as growing a matrix associated with a particular layer by duplicating the columns and rows of its weight matrix.
Suppose a layer has weight matrix W l ∈ R D 1 × D 1 .
4 To expand it to a matrix W ( new ) l ∈ R D 2 × D
We therefore have vec( L D )
∈ R
Our approach is agnostic with regard to vectorization
We define a single layer as f l ( x ) =
W l x + b l , where the row number of W l corresponds to the output dimension, and the column number of W l corresponds to the input dimension.
( D 2 > D 1 ), Net2Net copies W l to its upper-left corner of W ( new ) l , fills the new columns via a random selection matrix S l , and finally duplicates and normalizes rows according to the selection matrix from the previous layer.
Formally, the growth operator of Net2Net can be written as:
[Equation]
where S l ∈ { 0 , 1 } D 1 × ( D 2 − D 1 ) is a random selection matrix.
The diagonal of D l is a D 1dimensional histogram, whose i -th entry indicates number of times i -th column of W l was copied.
3. L EARNING TO G ROW WITH A S TRUCTURED L INEAR G ROWTH O PERATOR
While existing operators have been empirically successful in accelerating transformer-based models such as BERT (Gong et al., 2019; Chen et al., 2021), we observe that generally do not have a learning component and perform the depth- and width-expansions separately.
In this section we introduce a general framework for learning to grow with a linear growth operator (LiGO), which generalizes existing operators by combining the width- and depth-growth operators in a data-driven way.
We can formulate the problem of initializing the weights of the larger model Θ ( new ) from the smaller model Θ through the following optimization problem,
[Equation]
where D is the data distribution and L is the loss function.
It is of course intractable to optimize over the entire operator space, and thus we further simplify the function M to be a linear transformation, which results in the following formulation,
[Equation]
This simplified objective is still completely infeasible to apply to contemporary neural networks where L 1 D 1 can easily be in the hundreds of millions.
We therefore propose an efficient parameterization of M for tractable learning.
3.2. D ECOMPOSITION ALONG D EPTH AND W IDTH
Our first step is to decompose the LiGO operator as M = L depth R width , where L depth and R width expand the depth and width of model separately.
Concretely, we decompose M as
[Equation]
where R l ∈ R D 22 × D 21 and ℓ i,j ∈ R D 22 .
L depth is an array of diagonal matrices and R width is a block-diagonal matrix, i.e., both matrices are highly structured and sparse.
When applying
R width to weights vec( Θ ) , the parameters of each layer will be transformed independently via vec( W ( new ) l ) =
R l vec( W l ) and lifted to a higher dimension.
The l -th row block of L depth corresponds to the growth operator of l -th layer, which amounts to linearly combining all layers of the smaller model via vec( W ( new ) l ) k
= (cid:80) L 1 l ′ =1 ( ℓ l,l ′ )
k vec( W l ) k .
By this factorization, we can effectively reduce the complexity of LiGO operator from O ( D 21 L 1 D 22 L 2 ) to O
( D 21 D 22 L 1 ) and encode architectural knowledge by grouping parameters by layers.
Later in Sec. 3.4, this representation is also shown to preserve high representation power owing to its connection with Monarch matrices (Dao et al., 2022).
3.2. P ARAMETER S HARING VIA K RONECKER F ACTORIZATION
The above LiGO operator requires O ( D 21 D 22 L 1 ) parameters for R width and O ( L 1 L 2 D 22 ) for
L depth .
The width operator R width is thus still prohibitively expensive given that D 1 (and D 2 ) can easily be in the hundreds or thousands.
In this section, we propose a Kronecker factorization to further reduce the number of learnable parameters for each growth operator.
Depth.
For depth, we treat an entire layer as a single group and construct a new layer by combining existing layers, effectively tying parameters for all neurons in same layer.
Formally, each block in
L depth is simplified to be diag( ℓ i,j )
=
w i,j I .
Then the entire matrix can be written as a Kronecker factorization, L depth = w ⊗ I , where w ∈ R L 2 × L 1 is a matrix whose entry w i,j indicates blending weights of j -th layer of the small model to form i -th layer of the large model.
This strategy reduces the number of parameters in L depth to O
( L 1 L 2 ) , and is shown on left-hand side of Figure 1.
Width.
For width, we decompose each diagonal block of width expansion operator R width using the Kronecker factorization R l =
A l ⊗ B l , where A l , B l ∈ R D 2 × D 1 .
Since vec( CAB )
=
( B ⊤ ⊗ C ) vec( A ) (Schacke, 2004), we then have,
[Equation]
Here we observe that B l W l A ⊤ l performs in- and out-dimension expansion by A l and B l , respectively.
Each new column/row is a linear combination of columns/rows of small model’s weight matrix.
This factorization, which can be seen as grouping parameters by neurons , reduces the number of parameters to O
( L 1 D 1 D 2 ) .
Figure 1 (right) illustrates LiGO’s width-expansion operator.
Altogether, we obtain the final parameterization of LiGO operator M :
[Equation]
Depth expansion
[Equation]
[Equation]
We can exploit the factorization to implement the LiGO operator (Eq. 8) efficiently.
Training.
LiGO expands a model in three steps: (1) for each layer, inserting new rows by linearly combining existing rows through B l , (2) for each layer, inserting new columns by linearly combining existing columns through A l , and then finally (3) reconstructing each layer by linearly combining the weight matrices with w along the depth.
We then run a few steps (e.g., 100 iterations) of SGD to optimize M , which has negligible compute cost relative to regular training.
After obtaining M , we initialize large model with M vec( Θ ) , and train parameters Θ ( new ) through SGD as usual.
Algorithm 1 summarizes a forward pass of LiGO with transformer.
Finally, as shown in Appendix A we note that StackBERT (Eq. 1), Interpolation (Eq. 1), and Net2Net (Eq. 2) are all special cases of LiGO (Eq.
8) with a particular setting of L depth and R width .
3. L I GO FOR T RANSFORMERS
While LiGO can be applied to any multi-layer neural network architecture, in this paper we focus on using LiGO to grow transformers which have been shown to be particularly amenable to scaling.
Below we briefly describe how LiGO is applied to the main transformer embedding/attention layers and defer further details (e.g., growing bias vectors, layer norm parameters) to Appendix B.1.
Embedding layer.
The embedding layer can be regarded as a linear layer whose inputs are one-hot vectors.
We learn a matrix B ( emb ) to extend its output dimension.
This embedding layer is also used as the final output layer for our transformer language modeling experiments.
Attention and feedforward Layers.
An attention layer consists of multi-head attention weights ( W Q , W K , W V ) and a linear projection ( W O ).
Let A kl and B kl where k ∈ { Q, K, V, O } be the lth layer’s in- and out-dimension expansion matrices (Eq. 6) for the query, key, value, and projection matrices.
To make sure new input and output channels are aligned across modules, we tie the LiGO operator as follows: for all l ∈ [ L 1 ] , (1) A kl =
( B ( emb ) ) ⊤ for ∀ k ∈ { Q, K, V } , (2) A Ol = ( B Vl ) ⊤ , (3) B
Ol = B ( emb ) .
The last constraint is added to take into account the residual connections (Chen et al., 2021).
We similarly tie parameters for the feed-forward networks, A ( fc 1) l = ( B ( emb ) ) ⊤ , A ( fc 2) l
=
( B ( fc 1) ) ⊤ l and B ( fc 2) l = B ( emb ) . Since transformers make heavy use of residual layers with skip connections, we found that simply using the same B ( emb ) to parameterize A kl and B kl for many layers/modules worked well in practice.
This reduces the number of learnable parameters even further and enables fast learning of M on a small amount of data (100 gradient steps).
3. C ONNECTION TO M ONARCH M ATRICES
As shown in Sec.
3.2.1, our depth-width decomposition factorizes M into a multiplication of two structured sparse matrices.
We examine the expressiveness of this factorized representation by relating it to Monarch matrices (Dao et al., 2022), defined below.
Definition 1.
Let the space of Monarch matrices be M ⊆ R mn 1 ×
mn 2 .
Then matrix M ∈ M
if
M = P 1 LP ⊤ 2 R = P 1 diag( L 1 , · · · , L n 1 ) P
⊤ 2 diag( R 1 , · · · , R n 2 ) where L i ∈ R b 1 × b 2 , R i ∈ R b 3 ×
b 4 are dense rectangular matrices, and n 1 b 2 = n 2 b 3 .
P 1 is the permutation π ( i ) =
( i − b
⌊ ib 1 ⌋ − 1) n 1 + ⌊ ib 1 ⌋ + 1 and P 2 is the permutation π ( j ) =
( j − b 2 ⌊ jb 2 ⌋ − 1) n 1 + ⌊ jb 2 ⌋ + 1 .
It is clear that the block-diagonal matrix R has the identical form to our width growing operator
R width .
By applying the permutation matrices P 1 and P 2 to L , L is transformed into exactly the same form with our depth-growth operator L depth in Eq.
This implies that our depth-width decomposition coincides with Monarch sparsification of dense matrices, which generalize butterfly matrices (Dao et al., 2019) and enjoy rich expressivity properties (Dao et al., 2020; 2022).
E XPERIMENTS
We conduct experiments to answer three key research questions.
Q1:
To what extent can LiGO improve the training efficiency (FLOPs and wall time) of transformers compared to training from scratch and other growth operators?
Q2:
Can LiGO be universally effective across transformers from different domains (e.g., language and vision) and sizes?
Q3:
Can models trained using LiGO achieve similar performance compared to the baselines when transferred to downstream tasks?
4. E XPERIMENTAL S ETUP
Datasets.
We follow Tan & Bansal (2020) and use the English Wikipedia corpus 5 for training
BERT (Devlin et al., 2019) and RoBERTa (Liu et al., 2019).
We use the public C4 (Raffel et al., 2020) dataset for training GPT2 (Radford et al., 2019).
We use ImageNet (Deng et al., 2009) for training vision transformers.
We use GLUE (Wang et al., 2018), SQuADv1.1 (Rajpurkar et al., 2016), and SQuADv2.0 (Rajpurkar et al., 2018) for evaluating pretrained BERT models.
We test downstream performance of vision transformers (DeiT (Touvron et al., 2021a)) by performing transfer learning on 5 downstream image classification tasks, including CIFAR10 (Krizhevsky et al., 2009), CIFAR100 (Krizhevsky et al., 2009), Flowers102 (Nilsback & Zisserman, 2008), StanfordCars (Krause et al., 2013), and ChestXRay8 (Wang et al., 2017).
Models.
We experiment with growing the following language andd vision transformers: (1)
BERT-Small → BERT-Base, BERT-Base → BERT-Large, BERT-Small → BERT-Large; (2) RoBERTaSmall → RoBERTa-Base for RoBERTa; (3) GPT2-Base → GPT2-Medium, (4) DeiT-S → DeiT-B, and (5) CaiT-XS → CaiT-S. BERT-Small has 6 layers with 512 hidden dimensions, while other named models are their usual sizes.
See Appendix B.2 for full details.
Baselines.
We compare our approach with the following baselines: (1) training from scratch baseline where we train the larger transformer without using any smaller pretrained models; (2) progressive training methods designed for growing depth in transformers (StackBERT (Gong et al., 2019) and
MSLT (Yang et al., 2020)); (3) bert2BERT (Chen et al., 2021) that extends Net2Net (Chen et al., 2015) for width expansion and stacking for depth expansion; (4) KI (Qin et al., 2021) which uses distillation for transferring knowledge from the smaller model to the larger model.
Implementation details.
We always use 100 gradient steps to learn the LiGO for all models, which is negligible in terms of FLOPs/wall time compared to full training after initialization.
We train both BERT and RoBERTa models for 400 K steps with a warmup of 10 K steps.
We remove the nextsentence prediction task (Liu et al., 2019) and use a fixed sequence length of 128 for pretraining [Figure]
in reusing either BERT-Small or BERT-Base for accelerating BERT-Large training
[Table]
[Table]
both models. For BERT, we use a batch size of 256 and a learning rate of 2 e − 4 , while we use a batch size of 1024 and a learning rate of 8 e − 4 for training RoBERTa models. Following Shen et al. , we train GPT2 models with a batch size of 384 and sequence length of 1024 .
For vision transformers, we build our models based on DeiT (Touvron et al., 2021a) and
CaiT (Touvron et al., 2021b), and apply their default hyper-parameters for training on ImageNet dataset.
We train all our vision transformers for 300 epochs with a batch size of 1024 .
For transfer learning with BERT/RoBERTa, we follow Tan & Bansal (2020) and train for 3 epochs with a learning rate of 1 e − 4 and a batch-size of 32 for all tasks in GLUE.
On SQuAD v1.1 and SQuAD 2.0, we fine-tune for 2 epochs with a learning rate of 5 e − 5 and a batch size of 12 .
We run both GLUE and SQuAD evaluations three times with different random seeds and report the mean numbers.
For transfer learning experiments on DeiT, we finetune the pretrained models with 1000 epochs, batch size 768, learning rate 0 .
01 , and use the same data augmentation in training on ImageNet.
We use the same pretraining data and experimental settings for all the baselines (including our approach) for a fair comparison.
Note that we include the additional compute required for training LiGO in all our tables and figures.
However, since our LiGO is only trained for 100 steps, the influence on visualization and quantitative saving percentages is negligible.
4. R ESULTS AND A NALYSIS
BERT.
Figure 2 shows the comparison between the different baselines for training BERT models.
As seen from Figure 2(a), LiGO saves 44 .
7% computational cost (FLOPs) of training BERT-Base (12 layers, 768 dimensions) from scratch by reusing BERT-Small (6 layers, 512 dimensions).
LiGO offers 40 .
7% savings in wall time compared to training from scratch (Figure 2(b)).
Among the compared methods, StackBERT is the most competitive in terms of both FLOPs and wall time, although
LiGO obtains +10 .
and +7 .
2% improvements in FLOPs and wall time on top of StackBERT.
Similarly, LiGO significantly outperforms the recent bert2BERT method which saves about 30% computational costs.
We observe that KI does not provide any real savings in training as it requires additional computation for knowledge distillation.
Figure 2(c) shows that our LiGO approach is flexible in growing either BERT-Small or BERT-Base for accelerating BERT-Large training.
As expected, reusing BERT-Base instead of BERT-Small leads more savings in FLOPs ( 45 . 2% vs 30 . 3% ) as BERT-Base contains more implicit knowledge in its parameters.
Table 1 shows the per-task per-
[Figure]
formance of different BERT-Base models on both GLUE and SQuAD benchmarks, where we find that BERT trained with LiGO achieves very similar performance compared to the baselines on both benchmarks.
Finally, in Table 5 of the Appendix C.3, we show that growing BERT-Small to BERTBase with 100 steps of LiGO and then finetuning on GLUE tasks without additional pretraining outperforms just directly finetuning BERT-Small.
RoBERTa and GPT2.
Figure 3(a-b) shows the results on RoBERTa, whose training recipe uses larger batch size and learning rate than BERT.
LiGO similarly accelerates RoBERTa training, which indicates that our method is robust to optimization hyperparameters.
On GPT2, LiGO saves 22 . 5% computation cost of training GPT2-Medium (345M parameters) by reusing GPT2-Base (117M parameters)
(Figure 3(c)).
These consistent improvements show that LiGO is effective for accelerating transformer training across different model architectures and sizes.
[Figure]
Vision Transformers.
Figure 4 shows that by growing from DeiT-S, LiGO can save 55 .
4 % FLOPs and 52 % GPU wall time to reach the same performance of 81% on ImageNet.
Interestingly, the model initialized by our datadriven growth operator (w/ only 100 gradient steps of tuning) can already achieve 72 % accuracy at the beginning of training and leads to the final accuracy of 81 .
7% at the end of the training.
Compared to the next best method, bert2BERT, LiGO obtains more than 15% savings, which once again demonstrates the effectiveness of our approach in growing vision transformers as well.
Table 2 shows that finetuning results on downstream tasks perform on-par with the model trained from scratch, showing that LiGO does not harm the model’s generalization capabilities when transferred to downstream datasets.
We also find similar savings in CaiT-XS → CaiT-S where LiGO saves FLOPs by 52 .
6% and wall time by 46 .
1% over training CaiT-S from scratch on ImageNet (see Appendix C.2 for more details)
[Table]
[Table]
Combining with other training strategies.
We also find that LiGO can be effectively combined with orthogonal strategies such as layer dropping (Zhang & He, 2020), token dropping (Hou et al., 2022), and staged training (Chen et al., 2021).
More details are included in Appendix B.3. Figure 5 shows that LiGO can be combined with other training techniques to improve the computational savings by 4 . [Figure]
and 8 . 2% with layer dropping, token dropping and staged training, respectively.
Following (Chen et al., 2021), we also apply staged training strategy to bert2BERT and observe that LiGO still outperforms bert2BERT with staged training by 16 .
7% (see Figure 5(c)).
4. A BLATION S TUDIES
[Figure]
L o g P e
r
p
l e x i t y
ScratchStackBertInterBert
MSLTLiGO   5 1.
{+51.9% 0.0% (a) BERT(6,768) → BERT(12,768) 
+}
1 2 3 4 5 6 FLOPs (1e18) 1.
L o g P e
r
p
l e x i t y
ScratchDirectCopyFPI
AKILiGO   5 1.
[Figure]
Depth-only expansion
We examine the effectiveness of our proposed depth expansion operator ( L depth ) by only growing the depth of BERT from 6 layers to 12 layers, i.e, (BERT(6, 768) → BERT(12, 768).
We compare with stacking (StackBERT, Gong et al., 2019), Interpolation (InterBERT, Chang et al., 2017; Dong et al., 2020) (see Eq. 1), and MSLT (Yang et al., 2020).
For LiGO, we only apply its L depth component to the pre-trained model weights.
Results in Figure 6(a) show that a data-driven approach works well even when just growing across the depth dimension.
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
[Figure]
[Table]
Width-only expansion.
We also verify the effectiveness of R width by only extending BERT width from 512 to 768 , i.e., BERT(12, 512) → BERT(12, 768).
We compare LiGO based initialization with direct copy (Wei et al., 2016), function preserving initialization (FPI, Chen et al., 2015), and advanced knowledge initialization (AKI, Chen et al., 2021).
LiGO’s width expansion component outperforms all other methods, as shown in Figure 6(b).
Number of growing steps.
Our main experiments just usegradient steps to grow.
We tune our LiGO on the pretraining set for 100 , 500 , 1000 , andsteps and compute the additional FLOPs for BERT-Small → BERT-Base training.
Table 3 shows that training LiGO within 1000 steps results in the identical model convergence (reaching 1 . 8 PPL at 215 K steps).
This suggests tuning model weights under the linear constraints of LiGO can achieve faster convergence.
Training LiGO for more than 10000 steps can provide a model with slightly faster convergence ( 214 K steps), but results in less saving overall.
C ONCLUSION
This paper describes an approach for accelerating transformer training by learning to grow pretrained transformers, where the larger transformer’s parameters are initialized as a linear mapping from the smaller pretrained model’s parameters, The linear map is factorized to be a composition of sparse width- and depth-expansion operators with a Kronecker factorization that groups parameters into layers and neurons.
We demonstrate the effectiveness of our proposed approach on both language and vision transformers of different sizes, outperforming several competing methods.
While our compute resources prevented us from applying LiGO to even larger transformers, it would be interesting to see if this can be applied on top of even larger models. A CKNOWLEDGMENTS
PW sincerely thanks Zhen Wang for insightful discussion and providing reference repositories for language model pre-training.
PW also appreciates Hao Tan
’s assistance for reproducing fine-tuning results on GLUE datasets. YK and LTH were partially supported an MIT-IBM Watson AI grant and an Amazon award. We also acknowledge support from the IBM Research AI Hardware Center and the Center for Computational Innovation at Rensselaer Polytechnic Institute for the computational resources on the AiMOS Supercomputer A U NIVERSALITY OF L I GO O PERATOR
Proposition 1.
StackBERT (Eq. 1), Interpolation (Eq. 1), and Net2Net (Eq. 2) are all the special cases of the LiGO operator (Eq. 8).
Proof.
We prove Proposition 1 by constructing parameters in L depth and R width .
Stacking.
Stacking-based methods (Gong et al., 2019; Yang et al., 2020) duplicate the entire lower blocks on top of the small model to the form new layers (Eq. 1).
Formally, we show this operation can be done by the following operator:
[Equation]
Interpolation.
Interpolation based methods (Chang et al., 2017; Dong et al., 2020) interleave each layer for twice.
We can construct the following matrix to achieve layer interpolation (Eq. 1).
[Equation]
We remark that any rearrangement of layers to construct new layers (mathematically a permutation of existing layers with replacement) can be constructed in a similar way.
Net2Net.
Since we show in Eq. 6, the Kronecker factorization on R l amounts to decomposing the general growth operator into in-dimension and out-dimension expansion.
We can construct
Net2Net (Chen et al., 2015) based growth by simply letting:
[Equation]
L 2 D 2 ,
R width =   
A 1 ⊗ B. ..
A L 1 ⊗ B L  
A l = (cid:20) I (cid:101)
S l −(cid:21) ,
B l = (cid:20) IS l , (cid:21) (11) (12) where S l ∈ { 0 , 1 } ( D 2 − D 1) × D 1 is a selection matrix to enlarge the out dimension, and (cid:101) S l − 1 =
S l − 1 diag( 1 ⊤ S l − 1 ) − 1 copies the selection from S l − 1 with normalization to guarantee functionality preserving in expansion.
B I MPLEMENTATION D ETAILS B. G ROWING T RANSFORMERS WITH L I GO
The transformer architecture consists of an embedding layer, multi-block attention layer, and an output layer.
The core ingredient attention block consists of a Multi-Head Attention (MHA) module followed by a FeedForward Network (FFN), with a skip connection across the both blocks.
Applying LiGO requires the following considerations:
Embedding layer.
For both language and vision transformers, the embedding layer can be regarded as a linear layer, whose inputs are one-hot embeddings in language models.
We draw a learnable matrix B ( emb ) to extend its output dimension.
Multi-head attention blocks.
An attention layer in transformer consists of multi-head attention weights ( W Q , W K , W V ) and a linear projection ( W O ).
Let A kl and B kl with k ∈ { Q, K, V, O } be the in- and out-dimension expansion matrices (Eq. 6) for query, key, value, and projection in the l -th layer, respectively.
Applying B kl to W k ( k ∈ Q, K, V ) constructs new heads by a weighted summation of rows of all existing heads.
To make sure the new input and output channels are aligned across modules, we tie our LiGO operator with the following scheme: (1) A kl =
( B ( emb ) ) ⊤ for ∀ k ∈ { Q, K, V } , (2) A Ol = ( B ( V ) l ) ⊤ , (3) B
Ol = B
( emb )
for ∀ l ∈
[ L 1 ] .
Both the bias and layer normalization inherit the associated linear transformations’ out-dimension expansion matrices to grow the width.
For depth expansion, each module independently combines the same module from other layers (Eq.
8) with learnable coefficients w .
Feed-forward networks.
Each attention block is followed by a two-layer FFN.
Let A kl and B kl with k ∈ { fc 1 , fc 2 } be the in- and out-dimension expansion matrices (Eq. 6) for the first and second FFN layer in the l -th layer, respectively.
We tie the parameters for feed-forward networks: A [Equation]
) l [Equation] [Equation] and
[Equation]
Output layer.
For output head, we have A ( out ) =
B ( emb ) ⊤ , since the output dimension of attention layers are always aligned with B ( emb ) by our construction.
The output layer does not need out-dimension expansion.
Algorithm 1 summarizes LiGO for growing transformers.
B. M ODEL C ONFIGURATIONS
We summarize the settings of different transformer models used for our experiments in Table 4.
For
BERT and RoBERTa, we re-use the code base provided by Tan & Bansal (2020).
For GTP2, we follow the model configuration of OpenAI and use the pre-training code provided by Shen et al.
For DeiT, we use their official codebase (Touvron et al., 2021a).
[Table]
B. O RTHOGONAL E FFICIENT T RAINING S TRATEGIES
For layer dropping, we follow the same progressive dropping rate schedule with Zhang & He (2020), and set the maximum dropping rate to 0.1 to recover the performance.
For token dropping, we randomly set 15% tokens aside in the middle layers.
In the first 50 k steps of staged training, only a sub-network is activated and trained, and afterwards, we perform full-model training for 350k steps.
C A DDITIONAL E XPERIMENTS C. R EUSING SMALLER MODELS TRAINED FOR ONLY FEW STEPS
LiGO focuses on utilizing the knowledge of smaller models that have already been pretrained and available. In this section, we investigate how LiGO can leverage smaller existing models that are only trained for few steps to accelerate training of a larger model. We perform an experiment on
BERT-Base by reusing a BERT-Small trained for only 50k steps instead full training for 220k steps as used in our experiments. Figure 7 shows that LiGO can still save 35.2% savings in FLOPs and 30.2% savings in wall time over the BERT-Base training from scratch.
3: Ω ( emb ) ← B ( emb ) W ( emb ) do ▷ Width Expansion 5: Ω Ql ← B ( Q ) W Ql B ( emb ) ⊤ 6: Ω Kl ← B ( K ) W Kl B ( emb ) ⊤ 7: Ω Vl ← B ( V ) W Vl B ( emb ) ⊤ 8: Ω Ol ← B ( emb ) W Vl B ( V ) ⊤ 9: Ω ( ln 1) l ← B ( emb ) W ( ln 1) l 10: Ω ( fc 1) l ← B ( fc 1) W Vl B ( emb ) ⊤ 11: Ω ( fc 2) l ← B ( emb ) W V l B ( fc 1) ⊤ 12: Ω ( ln 2)
l ← B ( emb ) W ( ln 2) l 13: end
14: for l = 1 , · · · , L 2 do ▷
[Table] Expansion 15: Ω Ql ← (cid:80) L 1 j =1 w Ql,j Ω Qj 16: Ω Kl ← (cid:80) L 1 j =1 w Kl,j Ω Kj [-
 :-]17: Ω Vl ← (cid:80) L 1 j =1 w Vl,j Ω Vj 18: Ω Ol ← (cid:80) L 1 j =1 w Ol,j Ω Oj 19: Ω ( ln 1) l ← (cid:80)
L 1 j =1 w ( ln 1) l,j Ω
( ln 1) j 20: Ω ( fc 1) l ← (cid:80)
L 1 j =1 w ( fc 1) l,j Ω ( fc 1) j 21: Ω ( fc 2) l ← (cid:80)
L 1 j =1 w ( fc 2) l,j Ω ( fc 2)
j 22: Ω ( ln 2) l ← (cid:80)
L 1 j =1 w ( ln 2) l,j Ω ( ln 2) j 23: end for 24: Ω ( out ) ← W ( out ) B ( emb ) ⊤ 25: Train transformer with parameters Ω .
C. R ESULTS ON C AI T
In addition to DeiT (Touvron et al., 2021a), we perform additional experiments with CaiT (Touvron et al., 2021b) on ImageNet and find that while reusing CaiT-XS, LiGO offers about 52.6% savings in FLOPs and 46.1% savings in wall time over the CaiT-S training from scratch (see Figure 8).
C. T ASK - SPECIFIC FINETUNING WITH L I GO INITIALIZATION WITHOUT FURTHER PRETRAINING
We perform additional experiments by directly finetuning BERT-Base initialized by LiGO (from
BERT-Small) without any further pretraining.
We observe in Table 5 that the LiGO-initialized model can benefit downstream tasks compared to BERT-Small trained from scratch (1st row vs 2nd row).
C. GLUE P ERFORMANCE USING A DAPTER F USION
LiGO is mainly proposed for improving efficiency of the pre-training stage and hence is compatible with various finetuning schemes like full model finetuning, adapters (Houlsby et al., 2019; Pfeiffer et al., 2020) or prompt tuning (Lester et al., 2021; Jia et al., 2022) for adaptation to downstream tasks.
We test BERT-Base models trained using different baselines by using adapterfusion (Pfeiffer et al., 2020) instead of full finetuning on GLUE benchmark.
Table 6 shows that LiGO also achieves [Figure]
[Figure] [Table] [Table]
on-par performance with model trained from scratch under adapter-based tuning with
[Table]
7% savings in FLOPs abd 40.5% savings in wall time.
This shows that LiGO does not harm the model generalization capability when adapters are used as a parameter-efficient finetuning strategy for transferring a trained model to downstream datasets
[Table]
C. I NITIAL RESULTS ON BILLION + PARAMETER MODELS
Our extensive experiments on BERT (Devlin et al., 2019), RoBERTa (Liu et al., 2019), GPT2 (Radford et al., 2019), DeiT (Touvron et al., 2021a) and CaiT (Touvron et al., 2021b) show that LiGO can consistently improve transformer training efficiency over the traditional way of training from scratch across domains and model sizes.
One interesting future direction of our work is scaling
LiGO to very large models with parameters more than 100B, such as GPT3 (Brown et al., 2020).
While we currently do not possess the compute resources for this extreme large-scale study, we perform a preliminary experiment on GPT2-1.5B (Radford et al., 2019) by using GPT2-Medium as the initialization.
We train for 15k steps on C4 dataset (Raffel et al., 2020) and find that our proposed
LiGO saves about 39% computation cost (FLOPs) of training GPT2-1.5B from scratch to reach the same log perplexity (which is 3.3).
We believe that it is imperative to study the extent to which the benefits of LiGO remain at the scale on which the modern large language models are trained.
We hope to cover this in our future work.