Title: VeLoRA: Memory Efficient Training using Rank-1 Sub-Token Projections
Venue: NeurIPS 2024
Accepted: yes
Keywords: parameter efficient fine-tuning

memory efficient training
Abstract: Large language models (LLMs) have recently emerged as powerful tools for tackling many language-processing tasks. Despite their success, training and fine-tuning these models is still far too computationally and memory intensive. In this paper, we identify and characterise the important components needed for effective model convergence using gradient descent. In doing so we find that the intermediate activations used to implement backpropagation can be excessively compressed without incurring any degradation in performance. This result leads us to a cheap and memory-efficient algorithm for both fine-tuning and pre-training LLMs. The proposed algorithm simply divides the tokens up into smaller sub-tokens before projecting them onto a fixed 1-dimensional subspace during the forward pass. These features are then coarsely reconstructed during the backward pass to implement the update rules. We confirm the effectiveness of our algorithm as being complimentary to many state-of-the-art PEFT methods on the VTAB-1k fine-tuning benchmark. Furthermore, we outperform QLoRA for fine-tuning LLaMA and show competitive performance against other memory-efficient pre-training methods on the large-scale C4 dataset.

VeLoRA: Memory Efficient Training using Rank-1 Sub-Token Projections

Abstract

Large language models (LLMs) have recently emerged as powerful tools for tackling many language-processing tasks. Despite their success, training and finetuning these models is still far too computationally and memory intensive. In this paper, we identify and characterise the important components needed for effective model convergence using gradient descent. In doing so we find that the intermediate activations used to implement backpropagation can be excessively compressed without incurring any degradation in performance. This result leads us to a cheap and memory-efficient algorithm for both fine-tuning and pre-training LLMs. The proposed algorithm simply divides the tokens up into smaller sub-tokens before projecting them onto a fixed 1-dimensional subspace during the forward pass. These features are then coarsely reconstructed during the backward pass to implement the update rules. We confirm the effectiveness of our algorithm as being complimentary to many state-of-the-art PEFT methods on the VTAB-1k fine-tuning benchmark. Furthermore, we outperform QLoRA for fine-tuning LLaMA and show competitive performance against other memory-efficient pre-training methods on the large-scale C4 dataset. Code: https://github.com/roymiles/VeLoRA

1 Introduction

Large language models (LLMs) have achieved remarkable success on a wide range of natural language processing tasks [31, 47, 2]. However, training these massive deep learning models remains computationally expensive, requiring vast amounts of data, compute, and memory resources. A key bottleneck for training or adapting these models is the large memory needed to store all the intermediate features required to compute the gradients for optimization. This makes it challenging to fully leverage the scalability and performance gains promised by larger models on currently available hardware.

Several techniques have been proposed to reduce the memory requirements, such as GaLore [54], gradient checkpointing [8], reversible backpropagation [14], parameter-efficient finetuning [18, 7], quantization [11] and activation offloading [30]. GaLore uses a low-rank projection of the gradients during training to reduce the memory footprint. Gradient checkpointing reduces the activation memory demands by recomputing the activations in the backward pass instead of storing them. While these methods are promising and lower the memory cost, they also might introduce a substantial computational overhead, are limited in their memory savings, or require specialized hardware [11]. Knowing that compute is the primary mover for the advancements in machine learning [46], it is to be expected that the LLM sizes will continue growing exponentially. Thus, it is imperative to develop more efficient and scalable methods that allow better utilization of compute power and training data.

In this work, we present a novel approach for efficient training and finetuning, which we name Ve ctor projected LoRA (VeLoRA). Our approach is based on a key observation that the intermediate

+

update rule

grad input

Adapter

(a) Parameter-Efficient

Finetuning

(b) VeLoRA

forward

pass

tokens

backward

pass

LoRA, Hydra, etc.

+

update rule

grad input

LoRA, Hydra, etc.

Adapter

activations produced during the forward propagation of deep neural networks, and kept in memory for computing the gradients during backpropagation, can be effectively represented and reconstructed from a single and fixed one-dimensional vector without losing any accuracy. This compressed representation can be made very memory efficient, with a controllable hyperparameter that provides a trade-off between the compression ratio and the model's performance. By compressing and then reconstructing the activations on the fly, our method reduces the peak activation memory footprint to a tiny fraction of what is required to store the original activations. This enables fitting much larger models into limited GPU memory compared to approaches like GaLore or gradient checkpointing.

More concretely, during the forward pass, we propose to divide each input token into a set of much smaller sub-tokens. Using a single projection vector, we then project these individual sub-tokens onto a one-dimensional subspace. Importantly, we notice that we can initialize this projection vector cheaply using first-order batch statistics and then keep it fixed throughout training. We then reconstruct the original tokens using the same vector during the backward pass. Although this reconstruction loses the original gradient properties such as the direction or magnitude, we find that it jointly encourages sparsity and locally preserves the gradient similarity, which we attribute to the overall effectiveness of the algorithm. By storing these compact representations, we can substantially reduce the memory footprint of the network during training, enabling the accommodation of larger models on hardware with limited memory capacity.

Our contributions are the following:

We propose a novel compression method that reduces the memory requirement for gradient computation during training and fine-tuning of large neural network models like LLMs.

We show that, unlike other methods, our compression method does not need expensive operations such as SVD and gradient checkpointing.

We achieve state-of-the-art results in various benchmarks while requiring lower GPU memory compared to the baseline methods.

2 Related Work

Memory-Efficient Training. The increase in model size has necessitated the development of smart methods that make training more memory efficient. Gradient checkpointing [8] significantly lowers the memory requirements during model training by recomputing activations for the backward pass instead of storing them during the forward pass. However, doing so increases the training time from the need to re-compute gradients. Adafactor [41] and its followup [1] lowers the memory by working with the row-column outer-product factorized moments of adaptive optimizers. LOMO [30] was developed for large models and works by fusing the gradient computation and the parameter update in one step to reduce memory usage, effectively only saving the current layer gradients in memory. Recently, GaLore [54] proposed projecting the gradients onto a lower-dimensional space [9, 6], and can reduce the memory during both pre-training and finetuning. However, they store all the full intermediate activations to compute gradient updates. Their memory advantage is derived from

computing the first and second-order statistics of the gradients in a lower-dimensional space, thus limiting it to second-order optimizers only. Furthermore, GaLore needs an expensive SVD operation that introduces some significant overheads in terms of both memory and computation costs. Unlike these methods, VeLoRA does not introduce any large computation overhead while at the same time comes with a significant memory reduction. Furthermore, VeLoRA is in principle independent of the underlying optimizer.

Parameter-Efficient Fine-Tuning (PEFT) is an emerging field that focuses on fine-tuning a large model with a minimal number of trainable parameters. This typically involves freezing and then augmenting the original model with adapter modules. LoRA (Low-Rank Adaptation) [18] is a technique that optimizes a few rank-decomposed weight matrices during fine-tuning, rather than updating the entire set of pre-trained weights for each attention layer. This approach substantially reduces the number of trainable parameters, thereby accelerating the fine-tuning process and making it more memory-efficient. The method was later extended to also work with multi-layer perceptrons in Transformers [21, 13]. Several other methods built upon these works improving the capacity or performance of the model [21, 27, 7, 42, 35, 52, 49, 26, 45, 17]. These works can be wellcomplemented with quantization, further reducing the memory while keeping the performance [10, 11, 24]. Our memory-efficient algorithm is complementary to PEFT and can be used to provide additional memory efficiency in the fine-tuning regime.

Subspace training In [22, 15], the authors show that most of the learning process occurs within a significantly low-rank parameter space and that model weights can be effectively optimized within this lower-dimensional subspace. These subspace learning techniques have been widely adopted in various machine learning domains, including meta-learning [23] and continual learning [5]. However, unlike VeLoRA, resource-efficient training/fine-tuning is not the focus of these methods, therefore, often resulting in an overhead to meet other requirements.

Gradient Sparsification. Recently, there has been a surge in interest for memory-efficient training methods. In [50] only a sparse subset of the gradient vector components are stored zeroing out the remaining components. Different criteria have been proposed for selecting which gradient components to retain, such as Top-K SGD [43] which keeps only the top-k largest components, Sparsified-SGD [44] and various other sparsification methods [37, 38, 40, 25, 28, 16]. More recently, techniques combining quantization and sparsification have been proposed for resource-efficient training. Examples include TernGrad [51], Qsparse-local-SGD [3], sparse ternary compression [39], and the sparse-signSGD [32] method which combine sparsity with quantizing gradients to just the sign. A key difference is how VeLoRA compresses the intermediate activations that are used to compute gradients. Our compression algorithm is fully dense-to-dense without any pruning or sparsification of the activations. This prevents accuracy degradation issues associated with sparse updates and facilitates memory-efficient training.

1

2

4

8

16

4

6

8

10

12

14

16

18

stable rank

step

200

600

400

800

1k

0.0

0.2

0.4

0.6

0.8

1.0

k

0.0

0.2

0.4

0.6

0.8

1.0

Pr

0

/ 8

/4

/ 2

lower variance features

sparsify gradient

preserve similarity

equation 3

(a) sub-token stable rank

(b) gradient similarity

(c) visualising

compress

;

v

q

3 Method

The task. In this work, we propose a memory-efficient modification to the back-propagation algorithm. Our primary motivation is to reduce the GPU memory footprint during training without

resorting to any hardware-specific quantization schemes [11] and without trading compute for memory as is done with gradient checkpointing [8].

To formalize the problem statement, let us take a step back and look at the components needed to implement back-propagation. Firstly, during the forward pass, each trainable layer in the neural network needs to store two key tensors in memory - the input activations received by that layer, and the layer's trainable weight parameters. Retaining these tensors is required for performing the parameter update rules and computing the input gradients. More specifically, during the backward pass, the previously stored input activations and model weights are used to calculate the gradients with respect to the weights and the input via the chain rule of differentiation (see Fig. 1). Storing both these sets of tensors comes with a significant memory overhead which scales with the model size. We focus on optimizing the cost of storing the input activations. We do this by compressing intermediate activation vectors and then reconstructing them when the original activations are needed for gradient calculations. This is orthogonal to PEFT [18] methods which address the overhead of saving the full-precision weights in memory by introducing cheaper trainable adapters. Further, in Section 4, we show how to combine our method with PEFT methods to achieve state-of-the-art results.

3.1 VeLoRA

Overview. Here we address the challenge of compressing intermediate activations tensors while preserving the necessary training dynamics for model convergence. Our memory-efficient algorithm consists of two components: (i) The grouping strategy to divide the original high-dimensional tokens into much smaller sub-tokens; and (ii) Fixed rank-1 projections of these sub-tokens using cheap heuristically initialized principal components. Given a large pre-trained model, we apply these steps to compress the intermediate activations saved during training while preserving most of the original model's training dynamics. We illustrate the general overview of this pipeline in Fig 1 and show PyTorch-like pseudo-code in Algorithm 1.

Consider a set of input activations that need to be saved in GPU memory during the forward pass. We denote an element in this set as Z i ' ∇ w f p x i ; w q P I R N ˆ D , where N is the number of tokens, and D is the feature depth. We propose to introduce a simple grouping (reshape) operation that partitions the tokens across the depth dimension: group p¨q : Z P I R B ˆ N ˆ D Ý Ñ I R B ˆ ND { M ˆ M with M being the new size of each token, now coined a sub-token. This operation can be described as partitioning a batch of N tokens into a collection of these much smaller non-overlapping ND { M sub-tokens. Then we project each of the sub-tokens onto a rank-1 subspace. The idea is that this grouping operation enables a much lower-dimensional fixed subspace to be used throughout training without any degradation in model convergence or performance. We describe the compression steps concisely as follows:

where z is used to denote the sub-tokens of Z and z p are the compressed sub-tokens. This compression is achieved using the function compress p z ; v q ' z ¨ v , which projects each sub-token onto a onedimensional sub-space before saving them in memory. Since M ăă D it is more memory efficient to store z p instead of Z . The initialization strategy for v is important for the performance of the model, however we later show that a simple and cheap average over the first batch of sub-tokens can be very effective. Finally, the compressed sub-tokens z p are reconstructed for the gradient calculation during backward pass as follows:

Here ˆ z and ˆ Z refer to the reconstructed sub-tokens and tokens of z and Z respectively. The reconstruct function projects the sub-tokens z p back onto the vector v as a very coarse reconstruction of z and it is defined as reconstruct p z p ; v q ' z p ¨ v T . The overall compression and reconstruction operation is given as proj v p z q ' p z ¨ v q ¨ v T , where v P I R M ˆ 1 is a fixed vector of unit length.

To summarize, during the forward pass, we compress the intermediate activation tensor Z into a compact representation z p using v . Then, in the backward pass when the original activation Z is needed for gradient computation, we reconstruct an approximation ˆ Z by projecting z p back onto v .

These steps are fundamentally different and complementary to recent works that leverage the low-rank property of gradients like GaLore [54] in two ways: Firstly, they store the uncompressed intermediate activations in memory for the gradient computation. In contrast, we compress these activations explicitly during the forward pass. Secondly, GaLore relies on periodically computing the principal components with SVD to optimally capture the underlying gradient subspace. Our compression method avoids such costly operations, making it much more efficient and scalable.

3.2 Insights and properties of VeLoRA

On the importance of compressing subtokens. Computing the optimal low-rank subspace of the gradients using SVD is very computationally and memory intensive and often needs offloading the operation to a CPU [54]. Moreover, periodically updating the projection may be necessary to track any shift in the gradient distribution [54]. This is why dividing the tokens up into smaller sub-tokens is necessary. By doing so, it allows us to use a cheap surrogate rank-1 projective map that is initialised and frozen throughout training. Finally, one surprising observation of this grouping operation is that the sub-tokens will naturally lie on a higher-dimensional subspace than the original tokens (see figure 2a). Thus, our method cannot be faithfully explained through a better reconstruction of the gradients, but instead by a suppression of the inherently larger eigenvalues that can in turn help reduce overfitting.

Algorithm 1 VeLoRA, Pytorch-like

Why does a vector projection make sense? Using a fixed vector projection throughout training fails to capture any shift in the gradients' distribution. Under the assumption that preserving the original gradient reconstruction is important, this may seem like an undesirable trait. However, quite surprisingly, we find that this shift does not hinder the model's convergence or performance at all. An explanation behind this phenomenon can be twofold: (i) The gradients become more sparse as they shift away from the initial distribution and this helps prevent the model from overfitting to the fine-tuned dataset; (ii) Although the vector projection destroys the original gradients' magnitudes and directions, it still locally preserves the gradient similarity and this similarity will govern the model's training dynamics [19].

Consider a rank-1 decomposition of two sub-tokens: z i and z j . We will use the dot-product as the similarity measure sim p¨q for which we wish to locally preserve. Let us assume that both z i and z j are distributed such that the angles between them and the vector v are normally distributed with a mean of 0 and a standard deviation σ . With a first-order approximation, the probability of the projection and reconstruction scaling the gradient similarity by at least k is given as follows (see the Appendix for the full derivation):

With k ą 0 and σ ą 0 , this probability is bounded by r 0 , 1 s . Here we can see that similarity is trivially preserved in the limit as σ Ñ 0 . This indicates that the sub-tokens already lie on a 1-dimensional subspace spanned by v . To further see how these gradient similarities diverge for various values of k and σ , we plot equation 11 in Fig. 2c. We empirically observe that although the gradient similarity is very dependent on the distribution of features, this non-linear relationship does not hinder the model's ability to converge and generalise. Finally, we also provide an illustrative visualisation in Fig. 1 (right) that shows the locality sensitivity for preserving gradient similarity and the sparsification of gradients when they are orthogonal to the vector v . Both of these components are important properties that we attribute to the effectiveness of VeLoRA.

Connection to parameter efficient fine-tuning. Although VeLoRA is complimentary to LoRA, it can indeed be viewed under the same umbrella. First let us consider LoRA, which will freeze the

original weights and only update a low-rank adapter:

Following the same analysis from FLoRA [17], we will freeze A and initialise B with all zeroes. i.e. A ' A 0 and B 0 ' 0 . The weight update rule can then be given as follows:

with learning rate η and ˜ g ' dL dy ¨ dy dW - see FLoRA [17] for the original full derivation under the small learning rate assumption. In contrast, VeLoRA (with M ' D i.e. no sub-tokens) will update the original weights directly but with compressed gradients:

which leads to the following similar weight update rule to equation 5:

This result highlights that VeLoRA is a special case of LoRA with a data-driven initialisation for A 0 . Furthermore, due its construction, VeLoRA is implemented using a custom forward and backward operation rather than by modifying the architecture and fusing weights after training. Finally, VeLoRA also provides additional compression through having a smaller shared projection v for each sub-token . This would resemble reshaping the input tensor before and after the LoRA adapter to enable smaller projection matrices.

Cheap initialisation strategies. GaLore [54] proposes to use the periodically updated SVD principle components to track any shifts in the underlying sub-space of the gradients. Unfortunately, this SVD operation can be very expensive both in terms of memory and compute. Another limitation is that SVD may fail to converge, and it requires casting the features back to 32-bit for numerical stability [33]. For this reason, we propose a cheap initialisation strategy. We relax the constraint on tracking the feature distribution. For all of our experiments, we use a rank-1 decomposition of sub-tokens and propose to initialize the vector v using the average of sub-tokens from the first batch.

4 Comparison with the state-of-the-art

In this section, we thoroughly evaluate VeLoRA and its individual components. In section 4.2 we demonstrate the complementary nature of VeLoRA in conjunction with many other existing PEFT methods. Section 4.4 then scales up these results to the LLaMA models, whereby we achieve a significant memory reduction when coupled with 4-bit scalar quantisation. Finally, section 4.5 extends VeLoRA to the pre-training setting where we see competitive performance alongside a real reduction for the on-device GPU memory usage.

For the VTAB-1k experiments, we applied VeLoRA to all the down projections in the trainable adapters, while for SSF we applied it to the input scale and shift layers only. For all the other experiments we simply applied VeLoRA to the value projection layer and the down projection layer of the MLP blocks.

4.1 Implementation details

We performed all the vision experiments on a subset of the VTAB-1k [53] benchmark for a combination of 16 different vision datasets. We finetuned a ViT-B [12] model pre-trained on ImageNet-21K using the AdamW optimizer with a learning rate of 5e-4 and a weight decay of 1e-4. We performed

the language models experiments on the GLUE [48] benchmark using the encoder-decoder RoBERTa transformer [29]. We then scaled our model to large language models causal transformers using the LLama [2] family of models, finetuned in Alpaca dataset [36] and reported results on the MMLU benchmark [36]. We finally applied our method to the pre-training stage using some smaller LLama [2] models on the C4 dataset [34]. All our models were trained using the AdamW optimizer with a learning rate of 1e-3 and a weight decay of 0. We give all the other major hyper-parameters to replicate these experiments in the Appendix and also in the code.

4.2 Vision experiments

We conduct experiments evaluating the performance of VeLoRA for full-tuning and how it complements other PEFT methods. In Tab. 1 we reproduce a large set of results for LoRA [18], SSF [27], and Hydra [21] on a subset of the VTAB-1K benchmark, where the sub-token size for each experiment is given in the Appendix. Unlike what is more common in the PEFT literature [20, 21], we do not perform any task-specific hyperparameter tuning that would change the memory, such as batch size and rank, and to also avoid any potential overfitting to the specific task. For all experiments we used the authors provided implementations for the adapters and integrated them into the same training framework for a fair comparison. We observe that VeLoRA improves the performance compared to full-tuning by 1 . 5 percentage points ( pp ), while lowering the memory requirements. We also observe that when combined with PEFT methods, VeLoRA can come with improvement in memory and performance. VeLoRA lowers the memory requirement of SSF [27] by 16% with only a minor degradation (0.1 pp ) in accuracy. It lowers the memory requirement of Hydra [21] by 7% while improving the accuracy by 0.1 pp . Finally, it lowers the memory requirements of LoRA [18] by 4% while improving the accuracy by 0.6 pp .

4.3 Roberta experiments

We now evaluate our method with M ' 16 on various language tasks, using RoBERTa-Base [29] in the GLUE benchmark, and compare it with full fine-tuning, LoRA [18] and GaLore [54], presenting the results in Tab. 2. We observe that both GaLore and LoRA lower the memory requirements compared to fine-tuning from 4.64GB to 4.04GB, respectively to 2.71GB, at a cost of accuracy degradation with GaLore performance lowered by 0.39 pp , while LoRA accuracy drops by 0.67 pp .

Our method further reduces the memory needed for training to 2.23GB, an improvement of 18% compared to LoRA, and 45% compared to GaLore, while still reaching higher results than either of them. More impressively, VeLoRA reduces the memory by half compared to full fine-tuning with an accuracy degradation of only 0.37 pp , reaching the best tradeoff between memory and accuracy.

4.4 Scaling up to LLaMA

Wenowscale our method to large language models, demonstrating the effectiveness of VeLoRA in finetuning them. We do comparisons with LoRA on both BFloat16 and Float4, in addition to the recent method of QLoRA [11] which is widely used for fine-tuning LLMs with very low memory budget. We aim to further lower this budget, showing in the process that VeLoRA is also complementary to QLoRA, resulting in a much lower memory consumption. We present the results in Tab. 4.4 using M ' 32 for 7B and M ' 128 for 13B. We can see that our method outperforms QLoRA by 0.5 pp in the Llama model, while reaching a massive performance increase compared to LoRA models. Fur-

thermore, we reach this performance improvement, while at the same time further reducing the memory. In particular, we reduce the memory for 0.89GB, a relative improvement of 15.4% from QLoRA. We observe that this performance improvement is maintained on the larger model of 13B parameters, where again our method outperforms QLoRA by 0.5 pp and lowers the memory requirements by 1.43GB, a relative improvement of 14.4%.

4.5 Pre-training on C4

We now perform an experiment where we use VeLoRA to train language models from scratch in the large C4-English dataset, presenting the results in Tab. 4. We use M ' 128 for both the 60M and 130M, while following the same training pipeline and evaluation as GaLore and comparison with LoRA. However, unlike in the GaLore paper [54], which estimates the memory usage using the optimizer weights and memory alone, we choose to compute the real on-device memory. This quantity would take into account the cost of additionally storing the intermediate activations and also highlight the benefits of LoRA in terms of memory since the base weights will be frozen. In contrast to other experiments, our use of VeLoRA here is not with any additional adapters and is simply compressing the input activations for the original trainable base layers. We observe that our method significantly outperforms the other methods, reaching 1.08 pp lower perplexity than GaLore. We observe that our method outperforms GaLore in Llama-130M too.

5 Ablations Studies

5.1 Convergence properties

We observed that the rank-1 projections would encourage much higher levels of gradient sparsity (see Fig. 2b). A natural question to ask from this observation is if the gradient sparsity will come at the cost

of the model's convergence. In other words, we want to verify if our model needs to be trained longer to compensate for the gradient compression. To do so, we evaluate the performance of our model at the end of each epoch and compare it with the performance of a competing model, the QLoRA. As shown in Tab. 5a, VeLoRA and QLoRA improve at the same rate. Our model outperforms QLoRA by 0.3 pp by the end of the first epoch, and keeps this improvement rate, outperforming QLoRA by 0.4 pp at the end of the training. In this way, we verify that the additional compression of input activations does not affect the model's convergence.

5.2 Sub-token size

We provide an ablation on the impact on the size of each sub-token and the model's performance, showing the results in Tab. 5b. We can see that there is a sweet spot for which the rank-1 projections of sub-tokens using an average initialisation is very effective both in terms of memory and accuracy. However, if the size of the sub-tokens is too large (i.e. when M ' D { 8 ), the gradients will become too sparse, which will hinder performance (see also figure 2b). In contrast, if the size of each sub-token is too small, for example with D { 64 , there is a more significant memory compression but at the cost of model performance.

5.3 Initialisation strategy

In Tab. 5c, we show the performance after training with various ways of initialising the vectors for each group. To avoid exceeding memory requirements we sub-sampled the tokens for SVD and we also consider the case of instance-wise initialisation. Although we would have expected better performance since the vector will always align with each incoming batch, we found that it did not lead to any performance improvement. In contrast, doing SVD initialization comes with a drop in performance. This result further confirms that the performance improvement from VeLoRA is not specifically correlated with a lower reconstruction error of the input activations.

5.4 Choice of layers

A key design decision for many Parameter-Efficient Fine-Tuning (PEFT) methods, including LoRA, is where to insert the adapters within the model layers. Since VeLoRA shares this core architectural choice, we aim to provide stronger intuition on VeLoRA's suitability by performing a thorough ablation study analyzing the trade-offs between memory consumption and accuracy when considering different layer placements. We present the results in Tab. 6. We observe that we achieve memory improvement in all cases where we adopt VeLoRA. However, to improve the accuracy, VeLoRA

must be used in the MLP down-projection. A possible explanation is that this layer might suffer from overfitting on the training data or forgetting [4] from the pre-trained data. Overall, we conclude that applying VeLoRA to the value and down projection appears to be the best choice. We strengthen this claim by using this setting for all other experiments.

5.5 Comparison with gradient checkpointing

We compare VeLoRA to gradient checkpointing, another widely used technique to reduce the memory consumption during training. While both methods aim to minimize memory overhead, gradient checkpointing achieves this by recomputing the original activations during the backward pass, leading to a reduced memory consumption at the cost of additional compute. In contrast, VeLoRA uses a lossy compression of the activations during the forward pass and then reconstructs them in a coarser manner during the backwards, thus avoiding the need for any expensive recomputation. Our results in table 7 show that VeLoRA not only offers a comparable reduction in memory usage but also leads to faster training times compared to gradient checkpointing, as it reduces the recomputation burden and overhead.

6 Conclusion

In this work, we proposed VeLoRA, a novel framework that enables the training of networks, including large language models in a highly memory-efficient manner. Our approach compresses intermediate activations during the forward pass and coarsely reconstructs them during backpropagation. VeLoRA complements PEFT methods and is able to significantly reduce memory requirements while improving the performance. VeLoRA is effective when tested in both moderately-sized vision transformers as well as in large language models. We performed experiments to demonstrate the method's effectiveness on VTAB-1K, MMLU, GLUE, and C4 benchmarks outperforming state-of-the-art methods such as LoRA, QLoRA or GaLore.

Limitations and Broader Impact

Limitations. We performed all experiments on Transformer models. Although Transformers have become dominant in machine learning and computer vision, there are other important deep learning networks such as CNNs, RNNs and SSMs. It remains unclear whether our methods can be extended to non-Transformer-based models and how such an extension could be accomplished. Moreover, although our method is computationally more efficient than competing methods, its primary advantage lies in the substantial reduction of GPU memory. However, the issue of training time still persists.

Broader Impact. As compute power grows exponentially, model sizes grow even faster, making it challenging for smaller institutions, especially academic ones, to conduct high-quality research. This work aims to democratize AI research, particularly in large language models, by significantly reducing the memory needed for training, enabling researchers with limited compute resources to train networks and contribute to their research. However, the democratization of AI is controversial, with leading institutions like OpenAI, Anthropic, and Google DeepMind becoming more closed due to the potential risks of LLMs in the wrong hands. We acknowledge this concern and do not endorse misuse of our research.

References

R. Anil, V. Gupta, T. Koren, and Y. Singer. Memory efficient adaptive optimization. In NeurIPS , 2019.

R. Anil, S. Borgeaud, Y. Wu, J. Alayrac, J. Yu, R. Soricut, J. Schalkwyk, A. M. Dai, A. Hauth, K. Millican, D. Silver, S. Petrov, M. Johnson, I. Antonoglou, J. Schrittwieser, A. Glaese, J. Chen, E. Pitler, T. P. Lillicrap, A. Lazaridou, O. Firat, J. Molloy, M. Isard, P. R. Barham, T. Hennigan, B. Lee, F. Viola, M. Reynolds, Y. Xu, R. Doherty, E. Collins, C. Meyer, E. Rutherford, E. Moreira, K. Ayoub, M. Goel, G. Tucker, E. Piqueras, M. Krikun, I. Barr, N. Savinov, I. Danihelka, B. Roelofs, A. White, A. Andreassen, T. von Glehn, L. Yagati, M. Kazemi, L. Gonzalez, M. Khalman, J. Sygnowski, and et al. Gemini: A family of highly capable multimodal models. CoRR , 2023.

D. Basu, D. Data, C. Karakus, and S. Diggavi. Qsparse-local-sgd: Distributed sgd with quantization, sparsification and local computations. In NeurIPS , 2019.

D. Biderman, J. G. Ortiz, J. Portes, M. Paul, P. Greengard, C. Jennings, D. King, S. Havens, V. Chiley, J. Frankle, C. Blakeney, and J. P. Cunningham. Lora learns less and forgets less. TMLR , 2024.

A. Chaudhry, N. Khan, P. Dokania, and P. Torr. Continual learning in low-rank orthogonal subspaces. In NeurIPS , 2020.

H. Chen, G. Raskutti, and M. Yuan. Non-convex projected gradient descent for generalized low-rank tensor regression. J. Mach. Learn. Res. , 2019.

S. Chen, C. Ge, Z. Tong, J. Wang, Y. Song, J. Wang, and P. Luo. Adaptformer: Adapting vision transformers for scalable visual recognition. In NeurIPS , 2022.

T. Chen, B. Xu, C. Zhang, and C. Guestrin. Training deep nets with sublinear memory cost. CoRR , abs/1604.06174, 2016.

Y. Chen and M. J. Wainwright. Fast low-rank estimation by projected gradient descent: General statistical and algorithmic guarantees. CoRR , 2015.

T. Dettmers, M. Lewis, S. Shleifer, and L. Zettlemoyer. 8-bit optimizers via block-wise quantization. In ICLR , 2022.

T. Dettmers, A. Pagnoni, A. Holtzman, and L. Zettlemoyer. Qlora: Efficient finetuning of quantized llms. In NeurIPS , 2023.

A. Dosovitskiy, L. Beyer, A. Kolesnikov, D. Weissenborn, X. Zhai, T. Unterthiner, M. Dehghani, M. Minderer, G. Heigold, S. Gelly, J. Uszkoreit, and N. Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale, 2021.

V. Fomenko, H. Yu, J. Lee, S. Hsieh, and W. Chen. A note on lora. CoRR , 2024.

A. N. Gomez, M. Ren, R. Urtasun, and R. B. Grosse. The reversible residual network: Backpropagation without storing activations. In NeurIPS , 2017.

G. Gur-Ari, D. A. Roberts, and E. Dyer. Gradient descent happens in a tiny subspace. arXiv preprint , 2018.

P. Han, S. Wang, and K. K. Leung. Adaptive gradient sparsification for efficient federated learning: An online learning approach. In Conference on distributed computing systems (ICDCS) , 2020.

Y. Hao, Y. Cao, and L. Mou. Flora: Low-rank adapters are secretly gradient compressors, 2024.

E. J. Hu, Y. Shen, P. Wallis, Z. Allen-Zhu, Y. Li, S. Wang, L. Wang, and W. Chen. Lora: Low-rank adaptation of large language models. In ICLR , 2022.

A. Jacot, F. Gabriel, and C. Hongler. Neural tangent kernel: Convergence and generalization in neural networks. In NeurIPS , 2020.

S. Jie and Z.-H. Deng. Fact: Factor-tuning for lightweight adaptation on vision transformer. AAAI , 2023.

S. Kim, H. Yang, Y. Kim, Y. Hong, and E. Park. Hydra: Multi-head low-rank adaptation for parameter efficient fine-tuning. arXiv preprint , 2023.

B. W. Larsen, S. Fort, N. Becker, and S. Ganguli. How many degrees of freedom do we need to train deep networks: a loss landscape perspective. In ICLR , 2022.

Y. Lee and S. Choi. Gradient-based meta-learning with learned layerwise metric and subspace. In ICML , 2018.

B. Li, J. Chen, and J. Zhu. Memory efficient optimizers with 4-bit states. In ICLR , 2023.

S. Li and T. Hoefler. Near-optimal sparse allreduce for distributed deep learning. In Symposium on Principles and Practice of Parallel Programming , 2022.

V. Lialin, N. Shivagunde, S. Muckatira, and A. Rumshisky. Relora: High-rank training through low-rank updates. ICLR , 2024.

D. Lian, D. Zhou, J. Feng, and X. Wang. Scaling & shifting your features: A new baseline for efficient model tuning. In NeurIPS , 2022.

Y. Lin, S. Han, H. Mao, Y. Wang, and B. Dally. Deep gradient compression: Reducing the communication bandwidth for distributed training. In ICLR , 2018.

Y. Liu, M. Ott, N. Goyal, J. Du, M. Joshi, D. Chen, O. Levy, M. Lewis, L. Zettlemoyer, and V. Stoyanov. Roberta: A robustly optimized BERT pretraining approach. arXiv preprint , 2019.

K. Lv, Y. Yang, T. Liu, Q. Gao, Q. Guo, and X. Qiu. Full parameter fine-tuning for large language models with limited resources. CoRR , abs/2306.09782, 2023.

OpenAI. GPT-4 technical report. CoRR , 2023.

C. Park and N. Lee. S 3 gd-mv: Sparse-signsgd with majority vote for communication-efficient distributed learning. In IEEE International Symposium on Information Theory, ISIT , 2023.

A. Paszke, S. Gross, S. Chintala, G. Chanan, E. Yang, Z. DeVito, Z. Lin, A. Desmaison, L. Antiga, and A. Lerer. Automatic differentiation in PyTorch. 2017.

C. Raffel, N. Shazeer, A. Roberts, K. Lee, S. Narang, M. Matena, Y. Zhou, W. Li, and P. J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. J. Mach. Learn. Res. , 2020.

A. Renduchintala, T. Konuk, and O. Kuchaiev. Tied-lora: Enhacing parameter efficiency of lora with weight tying. ACL, 2024.

T. Rohan, I. Gulrajani, T. Zhang, Y. Dubois, X. Li, C. Guestrin, P. Liang, and T. B. Hashimoto. Stanford alpaca: An instruction-following llama model. Technical report, 2023.

D. Rothchild, A. Panda, E. Ullah, N. Ivkin, I. Stoica, V . Braverman, J. Gonzalez, and R. Arora. Fetchsgd: Communication-efficient federated learning with sketching. In ICLR , 2020.

A. Sahu, A. Dutta, A. M Abdelmoniem, T. Banerjee, M. Canini, and P. Kalnis. Rethinking gradient sparsification as total error minimization. In NeurIPS , 2021.

F. Sattler, S. Wiedemann, K.-R. Müller, and W. Samek. Robust and communication-efficient federated learning from non-iid data. IEEE transactions on neural networks and learning systems , 2019.

A. Shanbhag, H. Pirk, and S. Madden. Efficient top-k query processing on massively parallel hardware. In International Conference on Management of Data , 2018.

N. Shazeer and M. Stern. Adafactor: Adaptive learning rates with sublinear memory cost. In ICML , 2018.

Y. Sheng, S. Cao, D. Li, C. Hooper, N. Lee, S. Yang, C. Chou, B. Zhu, L. Zheng, K. Keutzer, J. E. Gonzalez, and I. Stoica. S-lora: Serving thousands of concurrent lora adapters. arXiv preprint , 2023.

S. Shi, X. Chu, K. C. Cheung, and S. See. Understanding top-k sparsification in distributed deep learning. arXiv preprint , 2019.

S. U. Stich, J.-B. Cordonnier, and M. Jaggi. Sparsified sgd with memory. In NeurIPS , 2018.

Y. Sung, J. Cho, and M. Bansal. VL-ADAPTER: parameter-efficient transfer learning for vision-and-language tasks. In CVPR , 2022.

R. Sutton. The bitter lesson. https://blog.biocomm.ai/2019/03/13/the-bitter-lesson-rich-suttonmarch-13-2019/, 2019.

H. Touvron, T. Lavril, G. Izacard, X. Martinet, M. Lachaux, T. Lacroix, B. Rozière, N. Goyal, E. Hambro, F. Azhar, A. Rodriguez, A. Joulin, E. Grave, and G. Lample. Llama: Open and efficient foundation language models. CoRR , 2023.

A. Wang, A. Singh, J. Michael, F. Hill, O. Levy, and S. R. Bowman. GLUE: A multi-task benchmark and analysis platform for natural language understanding. In ICLR , 2019.

Y. Wang, Y. Lin, X. Zeng, and G. Zhang. Multilora: Democratizing lora for better multi-task learning. CoRR , 2023.

J. Wangni, J. Wang, J. Liu, and T. Zhang. Gradient sparsification for communication-efficient distributed optimization. In NeurIPS , 2018.

W. Wen, C. Xu, F. Yan, C. Wu, Y. Wang, Y. Chen, and H. Li. Terngrad: Ternary gradients to reduce communication in distributed deep learning. In NeurIPS , 2017.

W. Xia, C. Qin, and E. Hazan. Chain of lora: Efficient fine-tuning of language models via residual learning. CoRR , 2024.

X. Zhai, J. Puigcerver, A. Kolesnikov, P. Ruyssen, C. Riquelme, M. Lucic, J. Djolonga, A. S. Pinto, M. Neumann, A. Dosovitskiy, L. Beyer, O. Bachem, M. Tschannen, M. Michalski, O. Bousquet, S. Gelly, and N. Houlsby. The visual task adaptation benchmark. CoRR , 2019.

J. Zhao, Z. Zhang, B. Chen, Z. Wang, A. Anandkumar, and Y. Tian. Galore: Memory-efficient llm training by gradient low-rank projection. In ICML , 2024.

7 Supplementary Material

7.1 Memory Estimates

In this section, we provide a detailed explanation of the memory estimates presented in the paper. For the ablation experiments in Tables 5b and 6, we only estimate the memory consumption allocated for storing the intermediate activations. We do this because all the other memory allocations (weights, optimizer states, etc.) would be the same for each experiment. The reported memory estimates will highlight the impact of each design choice or parameter on the memory of the intermediate activations, which is one of the focuses of this paper.

Additionally, for the QLoRA Llama experiments in Tab. 3, we also use the estimated memory, but we compute this from three components: (i) Saving the frozen base weights in memory, these weights are what are quantized; (ii) The trainable adapter weights, which are stored in fp16 format for all methods; and (iii) The memory cost of storing the input features for each trainable layer. We acknowledge that an efficient implementation of our method with 4-bit quantization is left for future work. However, for all other experiments using fp16, we want to highlight that we report the real on-device GPU memory usage.

7.2 Roberta Experiments

We fine-tune the pre-trained RoBERTa-Base model on the GLUE benchmark. For the training parameters, we follow the same settings as GaLore [54], which is given in table 8.

7.3 VTAB-1K Experiments

We reproduce all the reported PEFT methods under a fixed rank and batch-size setting across all tasks. This is to ensure that the memory usage is fixed for all the tasks. However, for Hydra [21] we do use the optimal scale and dropout parameters provided the authors (see table 9). The rank v.s. memory for each reported training run is provided in table 10. Here we were able to use a higher rank for LoRA to get better performance, while also reducing the total memory. We found that Hydra did not noticeably improve performance when increasing the rank and so for these we maintained the same rank for with and without the addition of VeLoRA.

7.4 Implementation Details

All of the experiments in sections 4.2 and 4.5 were performed using 8 NVIDIA V100 GPUs with the fp16 data type. For the LLaMA experiments in section 4.4, we trained on 4 NVIDIA A100 GPUs

using the QLoRA nf4 data type. The LLaMA experiments were based on the alpaca-lora repository 1 , while the RoBERTa and C4 experiments was based on the GaLore repository 2 .

7.5 Gradient Similarity

Using sim p z i , z j q ' | z i | | z j | cos θ ij and proj v p z i q ' | z i | cos θ iv we wish to see how much the gradient similarity is being preserved under various assumptions about the distributions of both z i and z j . We can introduce a measure for this divergence as follows:

Since θ vv ' 0 and | v | ' 1 , we can simplify this expression as follows:

Without loss in generality, we can assume | θ jv | ą | θ iv | and use θ ij ' θ jv ´ θ iv .

For simplicity, consider the case where both the input activations z i and z j are also normalised to unit length. In practise, these magnitudes will simply be scaling the divergence linearly.

Let both θ i and θ j be normally distributed with standard deviation σ and have the vector v be appropriately initialised such that their means are 0 . To understand how our projection degrades the gradient similarity, we will consider the probability of d p¨q exceeding some scalar k , i.e:

Small σ approximation For normally distributed θ i and θ j , cos p θ i q and cos p θ j q will not be uniformly distributed and instead follow a distribution that is more concentrated around their mean values. Thus, we can use a first-order approximation of cos p¨q :

Therefore, we can express d p¨q and Pr p d p¨q ą k q as follows:

Since θ j ´ θ i is normally distributed with variance 2 σ 2 we have:

Finally, using the cumulative distribution function (CDF) of the normal distribution:

NeurIPS Paper Checklist

1. Claims

Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?

Answer: [Yes]

Justification: The abstract reflects the paper's contributions.

2. Limitations

Question: Does the paper discuss the limitations of the work performed by the authors?

Answer: [Yes]

Justification: We have a section names Limitations where we discuss the limitations of our paper.

3. Theory Assumptions and Proofs

Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?

Answer: [Yes]

Justification: We provide the full derivation showing the divergence of gradient similarities between the original activations and our proposed representation. In this derivation we provide all the assumptions and show the full steps in the supplementary. For the connection to LoRA we use one of the main results given in FLoRA, while showing all the other steps in the main paper.

4. Experimental Result Reproducibility

Question: Does the paper fully disclose all the information needed to reproduce the main experimental results of the paper to the extent that it affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?

Answer: [Yes]

Justification: We provide the code and dataset information to make the paper reproducible. In addition, we explain our approach and give the hyperparameters.

5. Open access to data and code

Question: Does the paper provide open access to the data and code, with sufficient instructions to faithfully reproduce the main experimental results, as described in supplemental material?

Answer: [Yes]

Justification: We provide the code, and explain the datasets we used. All datasets are public.

6. Experimental Setting/Details

Question: Does the paper specify all the training and test details (e.g., data splits, hyperparameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?

Answer: [Yes]

Justification: Yes, we give all the training details of the method.

7. Experiment Statistical Significance

Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?

Answer: [No]

Justification: Most of our experiments are on large-scale datasets and tasks. Each model is trained until convergence and we have observed very little variation in performance across multiple runs.

8. Experiments Compute Resources

Question: For each experiment, does the paper provide sufficient information on the computer resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?

Answer: [Yes]

Justification: We discuss the compute resources used in section 4.1 and provide the code and checkpoints to reproduce all of the main experiments.

Guidelines:

The answer NA means that the paper does not include experiments.

The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.

The paper should provide the amount of compute required for each of the individual experimental runs as well as estimate the total compute.

The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make it into the paper).

9. Code Of Ethics

Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics https://neurips.cc/public/EthicsGuidelines ?

Answer: [Yes]

Justification: Yes, we obey NeurIPS' code of ethics.

10. Broader Impacts

Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?

Answer: [Yes]

Justification: We discuss both the potential positive and negative societal impacts of our method in a section called Broader Impact.

11. Safeguards

Question: Does the paper describe safeguards that have been put in place for responsible release of data or models that have a high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?

Answer: [No]

Justification: Unfortunately, safeguarding against negative usage of LLMs is an openproblem. While we do not endorse any inappropriate usage of our method, we acknowledge that malicious people might benefit from training large networks with limited computational resources.

12. Licenses for existing assets

Question: Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?

Answer: [Yes]

Justification: We cite all the datasets and code (e.g., LLama) we use in the paper

13. New Assets

Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?

Answer: [Yes]

Justification: We have released the code under an MIT license.

14. Crowdsourcing and Research with Human Subjects

Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and screenshots, if applicable, as well as details about compensation (if any)?

Answer: [NA]

Justification: We do not use any experiments that require crowdsourcing or human subjects.

15. Institutional Review Board (IRB) Approvals or Equivalent for Research with Human Subjects

Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?

Answer: [NA]

Justification: We do not use any experiments that require crowdsourcing or human subjects.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes a novel algorithm named VeLoRA, which achieves memory-efficient training by compressing the intermediate activations of large-scale language models into a fixed one-dimensional subspace. VeLoRA divides tokens into smaller sub-tokens and projects them during the forward pass, then reconstructs the activations during the backward pass, thereby reducing memory usage. Experimental results demonstrate that VeLoRA performs excellently across various benchmarks, complementing other parameter-efficient fine-tuning methods, and significantly reducing memory requirements while maintaining high performance.\n\nSTRENGTHS:\n1 The method is easy to understand and succinctly compresses the intermediate activations.\n\n2 The method has a relatively complete derivation and explanatory analysis.\n\nWEAKNESSES:\n1 The number of parameters used by VeLoRA, especially in Tables 1 and 2, is not specified.\n\n2 In Table 1, although there is an improvement in the average results compared to LoRA, the performance degrades on datasets such as Caltech101, Resisc45, and Clevr-Count. Why is this the case?\n\n3 For PEFT methods, the experiments on visual tasks are insufficient. According to the category in \"Yu B X B, Chang J, Wang H, et al. Visual tuning[J]. ACM Computing Surveys, 2023.\", VeLoRA experiments are based only on the Parameter Tuning category, neglecting Prompt Tuning and Adapter Tuning. Therefore, the current results do not fully demonstrate the universality of the proposed method.\n\n4 Although the authors mention time issues in the Limitations section, the training duration before and after introducing VeLoRA should be presented.\n\n5 For Tables 1 and 2, the improvements brought by VeLoRA are not significant. Although the authors declare this in Q7 of the Checklist, a significance analysis is still necessary, especially in cases where the improvement is not evident.\n\nQUESTIONS:\nsee Weaknesses.\n\nLIMITATIONS:\nThe authors mention training time issues in the Limitations section, but the relevant results are not presented.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2024-07-07"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper introduces VeLoRA, a novel method for memory-efficient training and fine-tuning of large language models. The key idea is to compress intermediate activations during the forward pass by projecting sub-tokens onto a fixed 1-dimensional subspace, then coarsely reconstructing them during backpropagation. This approach complements existing parameter-efficient fine-tuning (PEFT) methods and allows for significant memory savings without sacrificing model performance. The authors evaluate VeLoRA on several benchmarks including VTAB-1k, GLUE, MMLU, and C4, demonstrating competitive or improved results compared to state-of-the-art methods like LoRA, QLoRA, and GaLore while reducing memory requirements.\n\nSTRENGTHS:\n1.  VeLoRA presents an innovative solution to the critical problem of memory efficiency in training large language models. The method is conceptually simple yet highly effective, offering substantial memory savings without compromising performance.\n2. The authors provide extensive experiments across multiple benchmarks and model sizes, from vision transformers to large language models. This thorough evaluation demonstrates the broad applicability and scalability of VeLoRA.\n3. Complementary to existing methods: VeLoRA is shown to be compatible with and complementary to other PEFT methods, enhancing their memory efficiency. This makes the approach highly practical and easy to adopt in existing workflows.\n\nWEAKNESSES:\nLimited theoretical analysis: While the paper provides some intuition for why VeLoRA works, a more rigorous theoretical analysis could strengthen the understanding of its effectiveness and potential limitations.\n\nQUESTIONS:\nHow does VeLoRA affect training and inference times compared to baseline methods? Is there a significant computational overhead?\nAre there any particular types of tasks or model architectures where VeLoRA might be less effective or even detrimental to performance?\n\nLIMITATIONS:\nNA", "TITLE": "Official Review", "RECOMMENDATION": 7, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-11"}

comments: SUMMARY:
This paper proposes VeLoRA, an activation-compression method to reduce memory consumption. VeLoRA compresses the activations by multiplying them with a vector, and the activations are then decompressed before gradient back-propagation. VeLoRA has proven to be effective on both vision and language models.

STRENGTHS:
- The paper presents an interesting method to reduce memory consumption when training large models.
- Experimental results show that VeLoRA can not only reduce GPU memory, but also achieve better performance.

WEAKNESSES:
- VeLoRA reduces memory usage by compressing activations. However, the widely used gradient checkpointing method can almost entirely eliminate the need for storing intermediate activations by recomputing them. How much speed advantage does VeLoRA offer compared to gradient checkpointing?

- The rank-1 mapping method used in VeLoRA is not intuitive to me. Can you explain why the rank-1 mapping is effective from a theoretical or intuitive perspective? In my opinion, the rank-1 mapping is equivalent to a weighted average, so does this mean that setting $v$ as a constant value $ (1/\sqrt m, 1/\sqrt m, \ldots, 1/\sqrt m) \in \mathbb{R}^m $ would also be feasible?

- Although VeLoRA's reduction in memory usage is not significant, its improvement in model performance is impressive. Can you explain the reasons behind this effect?

QUESTIONS:
See weaknesses above.

Overall, VeLoRA is a very interesting method, but the paper should provide a more clear explanation of the intuition or insights behind the method. For this reason, I cannot definitively say that the paper is solid, but my view is generally positive.

LIMITATIONS:
Limitations and Broader Impact are discussed in the paper.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2024-07-12

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nIn this paper, the authors propose to compress the activations by down-projecting the input tensors with a vector to save memory for large-scale training. The empirical results show that their proposed method, VeLoRa, achieves better performance compared with previous work.\n\nStrengths:\n\n1. The topic of efficient training is important, given that the models are scaled up at a rapid rate.\n2. The paper is well written and easy to follow.\n3. The empirical results confirm the effectiveness of the proposed method.\n\nWeaknesses\n\n1. Missing several closely related work.\n2. In addition to activation low-rank projection, the authors also propose a token grouping strategy. However, the benefit of this technique is unclear to me.\n\n\nGiven the concerns above, I recommend a borderline rejection of this paper.\n\n[1] [Accelerating deep learning with lossy compression](https://open.library.ubc.ca/soa/cIRcle/collections/ubctheses/24/items/1.0412625) \\\n[2] [Flora: Low-Rank Adapters Are Secretly Gradient Compressors](https://arxiv.org/abs/2402.03293)\n\nSTRENGTHS:\n1. The topic of efficient training is important, given that the models are scaled up at a rapid rate.\n2. The paper is well written and easy to follow.\n3. The empirical results confirm the effectiveness of the proposed method.\n\nWEAKNESSES:\n1. Missing several closely related work. The most related topic is activation compression (e.g. see [1] as an example of such a line of research). In addition, the paper uses GaLore as the baseline. However, there is existing work showing superior performance without conducting expensive SVD operations (e.g. [2]). The paper lacks proper comparisons with these baselines.\n2. In addition to activation low-rank projection, the authors also propose a token grouping strategy. However, the benefit of this technique is unclear to me. In Table 5 (b), the authors show that different numbers of groups will behave inconsistently: some work better while some do not without a clear pattern. It might be the variance that is playing the important role here.\n\nQUESTIONS:\nSee the weaknesses.\n\nLIMITATIONS:\nThe authors have adequately addressed the limitations.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-13"}