Title: SVFT: Parameter-Efficient Fine-Tuning with Singular Vectors
Venue: NeurIPS 2024
Accepted: yes
Keywords: Parameter Efficient Fine Tuning

Large Language Models

Deep Learning
Abstract: Popular parameter-efficient fine-tuning (PEFT) methods, such as LoRA and its variants, freeze pre-trained model weights $\(\mathbf{W}\)$ and inject learnable matrices $\(\mathbf{\Delta W}\)$. These $\(\mathbf{\Delta W}\)$ matrices are structured for efficient parameterization, often using techniques like low-rank approximations or scaling vectors. However, these methods typically exhibit a performance gap compared to full fine-tuning. While recent PEFT methods have narrowed this gap, they do so at the expense of additional learnable parameters. We propose SVFT, a *simple* approach that structures $\(\mathbf{\Delta W}\)$ based on the specific weight matrix $\(\mathbf{W}\)$. SVFT updates $\(\mathbf{W}\)$ as a sparse combination $\(M\)$ of outer products of its singular vectors, training only the coefficients of these combinations. Crucially, we make additional off-diagonal elements in $M$ learnable, enabling a smooth trade-off between trainable parameters and expressivity—an aspect that distinctly sets our approach apart from previous works leveraging singular values. Extensive experiments on language and vision benchmarks show that SVFT recovers up to **96%** of full fine-tuning performance while training only **0.006 to 0.25%** of parameters, outperforming existing methods that achieve only up to **{85\%}** performance with **0.03 to 0.8%** of the trainable parameter budget.

SVFT: Parameter-Efficient Fine-Tuning with Singular Vectors

Abstract

Popular parameter-efficient fine-tuning (PEFT) methods, such as LoRA and its variants, freeze pre-trained model weights W and inject learnable matrices ∆W . These ∆W matrices are structured for efficient parameterization, often using techniques like low-rank approximations or scaling vectors. However, these methods typically exhibit a performance gap compared to full fine-tuning. While recent PEFT methods have narrowed this gap, they do so at the expense of additional learnable parameters. We propose SVFT 2 , a simple approach that structures ∆W based on the specific weight matrix W . SVFT updates W as a sparse combination M of outer products of its singular vectors, training only the coefficients of these combinations. Crucially, we make additional off-diagonal elements in M learnable, enabling a smooth trade-off between trainable parameters and expressivity-an aspect that distinctly sets our approach apart from previous works leveraging singular values. Extensive experiments on language and vision benchmarks show that SVFT recovers up to 96% of full fine-tuning performance while training only 0.006 to 0.25 %of parameters, outperforming existing methods that achieve only up to 85% performance with 0.03 to 0.8 %of the trainable parameter budget.

1 Introduction

Large-scale foundation models are often adapted for specific downstream tasks after pre-training. Parameter-efficient fine-tuning (PEFT) facilitates this adaptation efficiently by learning a minimal set of new parameters, thus creating an "expert" model. For instance, Large Language Models (LLMs) pre-trained on vast training corpora are fine-tuned for specialized tasks such as text summarization [13, 37], sentiment analysis [27, 21], and code completion [28] using instruction fine-tuning datasets. Although full fine-tuning (Full-FT) is a viable method to achieve this, it requires re-training and storing all model weights, making it impractical for deployment with large foundation models.

To address these challenges, PEFT techniques [14] (e.g., LoRA [15]) were introduced to significantly reduce the number of learnable parameters compared to Full-FT, though often at the cost of performance. DoRA [19] bridges this performance gap by adding more learnable parameters and being more expressive than LoRA. Almost all these methods apply a low-rank update additively to the frozen pre-trained weights, potentially limiting their expressivity. Furthermore, these adapters are agnostic to the structure and geometry of the weight matrices they modify. Finally, more expressive

0.3

0.5

0.85

1.5

2.5

4

7

12

20.5

35

Number of Trainable Params (M)

32.5

35.0

37.5

40.0

42.5

45.0

47.5

50.0

52.5

55.0

SVFT

P

SVFT

B

d

=2

SVFT

B

d

=4

SVFT

B

d

=8

SVFT

B

d

=16

SVFT

R

d

=16

LoRA

r

=1

DoRA

r

=1

LoRA

r

=32

VeRA

r

=1024

VeRA

r

=2048

BOFT

m

=2

b

=8

DoRA

r

=16

DoRA

r

=4

LoRA

r

=4

Full Fine-Tuning (2500M params)

0.3

0.5

0.85

1.5

2.5

4

7

12

20.5

35

Number of Trainable Params (M)

50.0

52.5

55.0

57.5

60.0

62.5

65.0

67.5

70.0

SVFT

P

SVFT

B

d

=2

SVFT

B

d

=4

SVFT

B

d

=8

SVFT

B

d

=16

DoRA

r

=16

DoRA

r

=4

LoRA

r

=32

LoRA

r

=1

DoRA

r

=1

VeRA

r

=2048

BOFT

m

=2

b

=8

Full Fine-Tuning (2500M params)

Accuracy (%)

PEFT methods (e.g., LoRA, DoRA, BOFT [20]) still accumulate a considerable portion of learnable parameters even in their most efficient configuration (e.g., setting rank=1 in LoRA and DoRA). The storage requirements for the learnable adapters can grow very quickly when adapting to a large number of downstream tasks [17].

Is it possible to narrow the performance gap between PEFT and Full-FT while being highly parameter-efficient? Yes, we propose SVFT: Singular Vectors guided Fine-Tuning - a simple approach that involves updating an existing weight matrix by adding to it a sparse weighted combination of its own singular vectors . The structure of the induced perturbation in SVFT depends on the specific matrix being perturbed. Our contributions can be summarized as follows:

We introduce SVFT, a new PEFT method. Given a weight matrix W , SVFT involves adapting it with a matrix ∆ W := ∑ ( i,j ) ∈ Ω m ij u i v T j where the { u i } and { v j } are the left and right singular vectors of W , Ω is an a-priori fixed sparsity pattern, and m ij for ( i, j ) ∈ Ω are learnable parameters. By controlling | Ω | we can efficiently explore the accuracy vs parameters trade-off.

SVFT achieves higher downstream accuracy, as a function of the number of trainable parameters, as compared to several popular PEFT methods (see Figure 1) and over several downstream tasks across both vision and language tasks. For instance, on GSM-8K using Gemma-2B our method recovers up to 96% of full fine-tuning performance while training only 0.006 to 0.25 %of parameters, outperforming existing methods that only recover up to 85% performance using 0.03 to 0.8% the trainable parameter budget (see Figure 1).

We introduce four simple variants for parameterizing weight updates, namely: Plain , Random , Banded , and Topk in SVFT (which differ in their choices of the fixed sparsity pattern Ω ) and validate these design choices empirically. Additionally, we theoretically show that for any fixed parameters budget, SVFT can induce a higher rank perturbation compared to previous PEFT techniques.

2 Related Work

Recent advancements in large language models (LLMs) have emphasized the development of PEFT techniques to enhance the adaptability and efficiency of large pre-trained language models.

LoRA. A notable contribution in this field is Low-Rank Adaptation (LoRA) [15], which freezes the weights of pre-trained models and integrates trainable low-rank matrices into each transformer layer. For a pre-trained weight matrix W 0 ∈ R d × n , LoRA constraints the weight update ∆ W to a low-rank decomposition: h = W 0 x +∆ Wx = W 0 x + BAx , where B ∈ R d × r , A ∈ R r × n and rank r ≪ min( d, n ) . We underline the (trainable) parameters that are updated via gradient descent.

LoRA variants. We highlight some recent approaches that further improve the vanilla LoRA architecture. Vector-based Random Matrix Adaptation (VeRA) [17] minimizes the number of

Magnitude

dimout

dimout

dimout

meR1xk

h

十

Direction.....

U

b=0

Pretrained Weights

WE Rdxd

A =N(0,o²)

B=0

Pretrained Weights

WERdxd

A = N(0,o²)

B=N(0,α²)

d=1

shared

across layers

across layers

shared

1/IW+△Wl

十

W e Rdk

B

十

M

Pretrained Weights

dimin

dimin

-frozen

]-trainable

X

-trainable

-frozen

dimin

-zeros

trainable parameters by utilizing a pair of low-rank random matrices shared between layers and learning compact scaling vectors while maintaining performance comparable to LoRA. Formally, VeRAcan be expressed as: h = W 0 x +∆ Wx = W 0 x + Λ b B Λ d Ax , where A and B are initialized randomly, frozen, and shared across layers, while Λ b and Λ d are trainable diagonal matrices.

An alternative approach, Weight-Decomposed Low-Rank Adaptation (DoRA) [19], decomposes pretrained weight matrices into magnitude and direction components, and applies low-rank updates for directional updates, reducing trainable parameters and enhancing learning capacity and training stability. DoRA can be expressed as: h = m W 0 +∆ W ∥ W 0 +∆ W ∥ c x = m W 0 + BA ∥ W 0 + BA ∥ c x , where ∥ · ∥ c denotes the vector-wise norm of a matrix across each column. Similar to LoRA, W 0 remains frozen, whereas the magnitude vector m (initialized to ∥ W 0 ∥ c ) and low-rank matrices A , B contain trainable parameters.

AdaLoRA [38] adaptively distributes the parameter budget across weight matrices based on their importance scores and modulates the rank of incremental matrices to manage this allocation effectively. PiSSA (Principal Singular Values and Singular Vectors Adaptation) [22] is another variant of LoRA, where matrices A , B are initialized with principal components of SVD and the remaining components are used to initialize W 0 . FLoRA [34] enhances LoRA by enabling each example in a mini-batch to utilize distinct low-rank weights, preserving expressive power and facilitating efficient batching, thereby extending the domain adaptation benefits of LoRA without batching limitations.

Other PEFT variants. Orthogonal Fine-tuning (OFT) [26] modifies pre-trained weight matrices through orthogonal reparameterization to preserve essential information. However, it still requires a considerable number of trainable parameters due to the high dimensionality of these matrices. Butterfly Orthogonal Fine-tuning (BOFT) [20] extends OFT's methodology by incorporating Butterfly factorization thereby positioning OFT as a special case of BOFT. Unlike the additive low-rank weight updates utilized in LoRA, BOFT applies multiplicative orthogonal weight updates, marking a significant divergence in the approach but claims to improve parameter efficiency and fine-tuning flexibility. BOFT can be formally expressed as: h = ( R ( m,b ) · W 0 ) x , where the orthogonal matrix R ( m,b ) ∈ R d × d is composed of a product of multiple orthogonal butterfly components. When m = 1 , BOFT reduces to block-diagonal OFT with block size b . When m = 1 and b = d , BOFT reduces to the original OFT with an unconstrained full orthogonal matrix.

SVD-based Variants. SVF [31], SVDiff [10], and SAM-Parser [25] also leverage the structure of W matrices by decomposing them into three consecutive matrices via Singular Value Decomposition (SVD). However, these methods fine-tune only the singular values while keeping other components fixed, making them comparable to SVFT P . In Appendix C.1, we present a comparison of SVFT P with SVF, confirming that their performance is similar, which supports our observations.

3 Method

In this section, we introduce Singular Vectors guided Fine-Tuning (SVFT). The main innovation in SVFT lies in applying structure/geometry-aware weight updates through sparse weighted combination of singular vectors.

dimout

InstantiationsofM

Plain

Banded

Random

Top-k

十

M

- frozen

X

-trainable

dimin

-zeros

3.1 SVFT Formulation

We now formally describe our method, SVFT for parameter-efficient fine-tuning of a pre-trained model. Let W 0 ∈ R d 1 × d 2 denote a weight matrix in the pre-trained model, such as a key matrix, query matrix, or an MLP matrix within a transformer block. To this matrix, we add a structured, learnable update ∆ W as follows.

As a first step, we compute the Singular Value Decomposition (SVD) of the given matrix: W 0 = U Σ V T . That is, U is the d 1 × d 1 matrix of left singular vectors (i.e., its columns are orthonormal), V T is the d 2 × d 2 matrix of right singular vectors (i.e., its rows are orthonormal), and Σ is a d 1 × d 2 diagonal matrix. Then, we parameterize our weight update as ∆ W = UMV T , where U , V are fixed and frozen, while M is a d 1 × d 2 sparse trainable matrix with pre-determined and fixed sparsity pattern 3 . That is, we first pre-determine a small fixed set of elements in M that will be allowed to be non-zero and train only those elements. The forward pass for SVFT can be written as,

We explore four simple choices for Ω , the pre-determined sparsity pattern of M .

Plain ( SVFT P ) . In this variant, we constrain M to be a diagonal matrix, which can be interpreted as adapting singular values and reweighting the frozen singular vectors. Since only the diagonal elements are learned, this is the most parameter-efficient SVFT variant.

Banded ( SVFT B d ) . In this approach, we populate M using a banded matrix, progressively making off-diagonals learnable. Specifically, for constants z 1 and z 2 , M ij = 0 if j < i -z 1 or j > i + z 2 , where z 1 , z 2 ≥ 0 . In our experiments, we set z 1 = z 2 = d to induce off-diagonal elements that capture additional interactions beyond those represented by singular values. This banded perturbation induces local interactions, allowing specific singular values to interact with their immediate neighbors, ensuring smoother transitions. This method, although deviating from the canonical form of SVD, provides a mechanism to capture localized interactions.

Random ( SVFT R d ) . A straightforward heuristic for populating M involves randomly selecting k elements to be learnable.

Topk ( SVFT T # p ) . The final design choice we explore involves computing the alignment between the left and right singular vectors as u T i v j . We then select the topk elements and make them learnable. However, note that this only works when left and right singular vectors have the same size. A possible interpretation of this is we make only the topk strong interactions between singular vector directions learnable. The subscript # p denotes the total number of learnable parameters.

We illustrate these SVFT design choices in Figure 3. Our empirical results demonstrate that these simple design choices significantly enhance performance compared to state-of-the-art PEFT methods. Note that SVFT P has a fixed number of learnable parameters, while the remaining variants are configurable. We hypothesize that further innovation is likely achievable through optimizing the sparsity pattern of M , including efficient learned-sparsity methods. In this paper, we explore these

four choices to validate the overall idea: determining a perturbation using the singular vectors of the matrix that is being perturbed.

3.2 Properties of SVFT

We highlight some properties of SVFT in the following lemma and provide insights into how its specific algebraic structure compares and contrasts with baseline PEFT methods.

Lemma: Let W 0 be a matrix of size d 1 × d 2 with SVD given by U Σ V T . Consider an updated final matrix W 0 + UMV T , where M is a matrix of the same size as Σ , which may or may not be diagonal. Then, the following holds:

(a) Structure: If M is also diagonal (i.e. the plain SVFT), then the final matrix W 0 + UMV T has U as its left singular vectors and sign( Σ + M ) V T as its right singular vectors. That is, its singular vectors are unchanged, except for possible sign flips. Conversely, if M is not diagonal (i.e., variants of SVFT other than plain), then U and V may no longer be the singular directions of the final matrix W 0 + UMV T .

(b) Expressivity: Given any target matrix P of size d 1 × d 2 , there exists an M such that P = W 0 + UMV T . That is, if M is fully trainable, any target matrix can be realized using this method.

(c) Rank: If M has k non-zero elements, then the rank of the update UMV T is at most min { k, min { d 1 , d 2 }} . For the same number of trainable parameters, SVFT can produce a much higher rank perturbation than LoRA (eventually becoming full rank), but in a constrained structured subspace.

We provide our proofs in Appendix A. Building on this lemma, we now compare the form of the SVFT update with LoRA and VeRA. SVFT's ∆ W can be written as a sum of rank-one matrices:

where u i is the i th left singular vector, v j is the j th right singular vector, and Ω is the set of non-zero elements in M . Thus, our method involves adding a weighted combination of specific rank-one perturbations of the form u i v T j .

LoRA and VeRA updates can also be expressed as sums of rank-one matrices.

where a i and b j are the trainable columns of A and B matrices in LoRA. In VeRA, ˆ a i and ˆ b i are random and fixed vectors, while α and β represent the diagonal elements of Λ d and Λ b respectively.

Note that LoRA requires d 1 + d 2 trainable parameters per rank-one matrix, while SVFT and VeRA require only one. Although LoRA can potentially capture directions different from those achievable by the fixed { u i , v T j } pairs, each of these directions incurs a significantly higher parameter cost.

VeRA captures new directions at a parameter cost similar to SVFT; however, there is a key distinction: in VeRA, each vector ˆ a i or ˆ b i appears in only one of the rank-one matrices. In contrast, in SVFT, the same vector u i can appear in multiple terms in the summation, depending on the sparsity pattern of M . This results in an important difference: unlike SVFT, VeRA is not universally expressive - it cannot represent any target matrix P . Moreover, ˆ a i , ˆ b i are random, while u i , v j depend on W 0 .

Note. SVFT requires storing both left and right singular vectors due to its computation of the SVD on pre-trained weights. While this increases memory usage compared to LoRA, it remains comparable to or lower than DoRA and BOFT. We present a memory analysis in Section 5.3. Further exploration of memory-reduction techniques, such as quantization, is planned as future work. Importantly, inference time and memory consumption remain the same across all methods, including SVFT, as the weights can be fused.

4 Experiments

4.1 Base Models & Setup

We adapt widely-used language models, encoder-only model (DeBERTaV3base [11]) and two decoder-only models (Gemma-2B/7B [32], LLaMA-3-8B [1]). We also experiment with vision transformer models (ViT-B/16 and ViT-L/16) [9]) pre-trained on ImageNet-21k [8], following prior work [17]. The complete details of our experimental setup and hyperparameter configurations are provided in Appendix C.

Baselines. We compare with Full Fine-Tuning (FT) updating all learnable parameters in all layers, along with LoRA [15], DoRA [19], BOFT [20] and VeRA [17]. 4

Target Modules. We adapt all weight matrices for SVFT, as it does not increase trainable parameters at the same rate as baseline methods. For baselines, we adapt the target modules recommended in [19]: QKVUD matrices for LoRA and DoRA, compatible matrices for VeRA, and QV matrices for BOFT to stay within GPU memory limits. Additional details can be found in Appendix C.7 and C.8. We also conduct experiments adapting QKVUD modules across methods and observe similar trends, as discussed in Appendix C.2.

4.2 Datasets

Language. For natural language generation (NLG) tasks, we evaluate on GSM-8K [7] and MATH [12] by fine-tuning on MetaMathQA-40K [35], following [20]. We also evaluate on 8 commonsense reasoning benchmarks (BoolQ [5], PIQA [3], SIQA [30], HellaSwag [36], Winogrande [29], ARC-easy/challenge [6], and OpenBookQA [23]). We follow the setting outlined in prior work [19, 16], where the training sets of all benchmarks are amalgamated for fine-tuning. We fine-tune on 15K examples from this training set. For natural language understanding (NLU), we evaluate on the General Language Understanding Evaluation (GLUE) benchmark consisting of classification and regression tasks, in line with [17, 15].

Vision. Our experiments on vision tasks consist of 4 benchmarks: CIFAR-100 [18], Food101 [4], RESISC45 [33], and Flowers102 [24]. We follow the setup from [17], and fine-tune on a subset comprising 10 samples from each class.

5 Results

5.1 Performance on Language Tasks

Natural Language Generation. We present results on mathematical question answering against baseline PEFT techniques across three base models - varying from 2B to 8B parameters in Table 1. To ensure a comprehensive comparison, we test baseline techniques (LoRA, DoRA) with different configurations, and varying hyper-parameters like rank to cover a range of learnable parameters from low to high. Note that even when the rank is as low as 1, both methods yield more trainable parameters than SVFT P . SVFT P ( ∼ 0.2M) shows as much as 18% relative improvement over techniques that use 6 × more trainable parameters (BOFT b =8 m =2 , LoRA r =1 ). Against techniques of comparable size (VeRA), SVFT P achieves 15.5% relative improvement on average. Even in the default regime, SVFT R d matches techniques with at least 3 × more trainable parameters. Notably, on GSM-8K, SVFT R d again achieves 96% of full fine-tuning performance, while DoRA r =16 recovers 86% with 2 × more parameters than SVFT R d .

Commonsense Reasoning. In Table 2, we compare performance on commonsense reasoning benchmarks with Gemma-7B, and observe similar trends. In the lower and moderately parameterized regime ( ∼ 0.43M), SVFT P shows competitive performance in comparison to LORA r =1 and

DoRA r =1 , which have 1.9 × and 7.7 × more parameters, respectively. Against VeRA, which trains 3.5 × more parameters, SVFT P shows a relative improvement of ∼ 1.16 %. Similarly, SVFT B d =8 also matches or exceeds methods that use up to 7 × more trainable parameters. For instance, SVFT B d =8 attains an average performance of 83.35% with only 9.8M parameters, closely matching LORA r =16 (83.69%, 68.8M parameters). We observe similar trends with Gemma-2B (refer Table 11).

Natural Language Understanding. Results on the GLUE benchmark are summarized in Table 3. SVFT matches LoRA r =8 and DoRA r =4 which use 12-22 × more trainable parameters. Similarly, when compared to OFT and BOFT, SVFT P maintains a comparable average performance despite being 12 × smaller. These results highlight SVFT's ability to strike a balance between parameter efficiency and performance, making it an attractive PEFT choice for simple classification tasks.

Parameter efficiency. In Figure 1, we plot the performance of SVFT on mathematical reasoning and commonsense reasoning against other PEFT techniques across a range of configurations. Across trainable parameter budgets ranging from lowest to highest, SVFT obtains the best overall performance, matching methods that require significantly more trainable parameters. These results establish SVFT as a pareto-dominant approach for parameter-efficient fine-tuning.

5.2 Performance on Vision Tasks

Table 4 presents a comparison between SVFT and other PEFT techniques on image classification benchmarks, using ViT-B and ViT-L models. The results show that SVFT variants achieve a strong balance between performance and parameter efficiency, often surpassing or matching the performance of other methods with fewer learnable parameters. Notably, the SVFT B variant attains an average accuracy of 83 . 87% across tasks with ViT-Base, outperforming Full-FT, which achieves a close 83 . 72% .

0.05

0.1

0.2

0.4

0.8

1.6

3

5.5

Number of Trainable Params (M)

30

32

34

36

38

40

42

44

46

48

Accuracy (%)

Weight Types

Q,V

Q,K,V

U,D

Q,K,V,U,D

Q,K,V,U,D,G,O

Configuration

P

d

=2

d

=4

d

=8

Additionally, it's important to note that in these vision experiments, both classifier head parameters and other learnable parameters are trained.

5.3 Memory Analysis

Although SVFT reduces trainable parameters, it results in higher overall GPU memory usage compared to LoRA. However, fewer trainable parameters lower the memory demands for gradients,

activations, optimizer states, and other buffers. To validate this, we used HuggingFace's internal memory profiler to measure peak GPU memory usage. Our results, along with the adapted modules for all baselines, are summarized in Table 5. We observe that SVFT uses approximately 1.2x more memory than LoRA but remains comparable to or more efficient than DoRA. We present additional analysis in Appendix C.5.

5.4 Contribution of Each Weight Type

In Figure 4, we investigate the contribution of each weight type. Starting with the base configuration, we apply SVFT B d to the Q and V weights in each transformer block and report the performance. We then incrementally add the remaining weight modules ( K , U , D , O , G ) and observe the changes in performance. For each configuration, we also vary the trainable parameters by incrementing the total learnable off-diagonals.

Note that applying SVFT B d to U , D , O , and G does not increase trainable parameters as much as applying LoRA/DoRA to these modules (Table 8). For example, for a large matrix of shape d 1 × d 2 , LoRA r =1 learns d 1 + d 2 parameters, while SVFT P learns min( d 1 , d 2 ) parameters. We observe that adapting only U and D with SVFT yields up to a 10% relative improvement over adapting Q and V for the same parameter budget ( ∼ 0 . 8 M ). Our findings indicate that adapting more weight types enhances performance.

5.5 Impact of M 's Structure on Performance

We analyze the impact of various parameterizations of M (Plain, Banded, Random, Topk ) on downstream performance. To ensure a fair comparison, we align the number of trainable coefficients across all variants whenever possible. As shown in Table 7, the Banded variant outperforms the others, followed closely by the Random variant, across different models and tasks. This trend is also evident in the average rank column of the table. Based on these empirical findings, we recommend using the Banded variant.

5.6 Impact of Pre-trained Weight Quality

A key feature of SVFT is that the weight update depends on the pre-trained weights W . We therefore ask the following question: Does the quality of pre-trained weights have a disproportionate impact on SVFT ? To

answer this, we consider two checkpoints from the Pythia suite [2] at different stages of training, i.e., 39K steps and 143K steps, respectively. We fine-tune each of these checkpoints independently with Full-FT, LoRA, and SVFT. We then compare the increase in performance ( ∆ Perf). As shown in Table 6, compared to LoRA, SVFT benefits more from better pre-trained weights. We also note that SVFT outperforms LoRA in both settings, suggesting that the benefits of inducing a ∆ W that explicitly depends on W are beneficial even when W is sub-optimal.

6 Discussion

Limitations. Despite significantly reducing learnable parameters and boosting performance, SVFT incurs some additional GPU memory usage. Unlike LoRA, SVFT necessitates computing the SVD and storing both left and right singular vectors. While memory consumption remains comparable to or lower than DoRA and BOFT, it's roughly 1.2 × that of LoRA. However, similar to the scaling explored in [34], memory usage should amortize with the increasing scale of adaptation tasks. In future work we will explore quantization and other techniques to address memory concerns.

Broader Impact. Our work enables easier personalization of foundational models, which can have both positive and negative societal impacts. Since our method provides computational efficiency (smaller parameter footprint), it will be less expensive to enable personalization.

7 Conclusion

This work introduces SVFT, a novel and efficient PEFT approach that leverages the structure of pretrained weights to determine weight update perturbations. We explore four simple yet effective sparse parameterization patterns, offering flexibility in controlling the model's expressivity and the number of learnable parameters. Extensive experiments on language and vision tasks demonstrate SVFT's effectiveness as a PEFT method across diverse parameter budgets. Furthermore, we theoretically show that SVFT can induce higher-rank perturbation updates compared to existing methods, for a fixed parameter budget. In future work, we aim to develop principled methods to generate sparsity patterns, potentially leading to further performance improvements.

References

Meta AI. Introducing meta llama 3: The most capable openly available llm to date. April 2024.

Stella Biderman, Hailey Schoelkopf, Quentin Anthony, Herbie Bradley, Kyle O'Brien, Eric Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, Aviya Skowron, Lintang Sutawika, and Oskar van der Wal. Pythia: A suite for analyzing large language models across training and scaling, 2023.

Yonatan Bisk, Rowan Zellers, Ronan Le Bras, Jianfeng Gao, and Yejin Choi. Piqa: Reasoning about physical commonsense in natural language. In Thirty-Fourth AAAI Conference on Artificial Intelligence , 2020.

Lukas Bossard, Matthieu Guillaumin, and Luc Van Gool. Food-101 - mining discriminative components with random forests. In European Conference on Computer Vision , 2014.

Christopher Clark, Kenton Lee, Ming-Wei Chang, Tom Kwiatkowski, Michael Collins, and Kristina Toutanova. Boolq: Exploring the surprising difficulty of natural yes/no questions, 2019.

Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge, 2018.

Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168 , 2021.

Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A largescale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition , pages 248-255. Ieee, 2009.

Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, and Neil Houlsby. An image is worth 16x16 words: Transformers for image recognition at scale. In International Conference on Learning Representations , 2021.

Ligong Han, Yinxiao Li, Han Zhang, Peyman Milanfar, Dimitris Metaxas, and Feng Yang. Svdiff: Compact parameter space for diffusion fine-tuning. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV) , pages 7323-7334, 2023.

Pengcheng He, Jianfeng Gao, and Weizhu Chen. Debertav3: Improving deberta using electrastyle pre-training with gradient-disentangled embedding sharing, 2023.

Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. Measuring mathematical problem solving with the math dataset, 2021.

Karl Moritz Hermann, Tomáš Koˇ ciský, Edward Grefenstette, Lasse Espeholt, Will Kay, Mustafa Suleyman, and Phil Blunsom. Teaching machines to read and comprehend. In Proceedings of the 28th International Conference on Neural Information Processing Systems , NIPS'15, page 1693-1701. MIT Press, 2015.

Neil Houlsby, Andrei Giurgiu, Stanislaw Jastrzebski, Bruna Morrone, Quentin De Laroussilhe, Andrea Gesmundo, Mona Attariyan, and Sylvain Gelly. Parameter-efficient transfer learning for NLP. In Proceedings of the 36th International Conference on Machine Learning , Proceedings of Machine Learning Research. PMLR, 2019.

Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-rank adaptation of large language models. In International Conference on Learning Representations , 2022.

Zhiqiang Hu, Lei Wang, Yihuai Lan, Wanyu Xu, Ee-Peng Lim, Lidong Bing, Xing Xu, Soujanya Poria, and Roy Ka-Wei Lee. Llm-adapters: An adapter family for parameter-efficient fine-tuning of large language models, 2023.

Dawid Jan Kopiczko, Tijmen Blankevoort, and Yuki M Asano. ELoRA: Efficient low-rank adaptation with random matrices. In The Twelfth International Conference on Learning Representations , 2024.

Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.

Shih-Yang Liu, Chien-Yi Wang, Hongxu Yin, Pavlo Molchanov, Yu-Chiang Frank Wang, Kwang-Ting Cheng, and Min-Hung Chen. Dora: Weight-decomposed low-rank adaptation, 2024.

Weiyang Liu, Zeju Qiu, Yao Feng, Yuliang Xiu, Yuxuan Xue, Longhui Yu, Haiwen Feng, Zhen Liu, Juyeon Heo, Songyou Peng, Yandong Wen, Michael J. Black, Adrian Weller, and Bernhard Schölkopf. Parameter-efficient orthogonal finetuning via butterfly factorization. In The Twelfth International Conference on Learning Representations , 2024.

Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach, 2019.

Fanxu Meng, Zhaohui Wang, and Muhan Zhang. Pissa: Principal singular values and singular vectors adaptation of large language models. arXiv preprint arXiv:2404.02948 , 2024.

Todor Mihaylov, Peter Clark, Tushar Khot, and Ashish Sabharwal. Can a suit of armor conduct electricity? a new dataset for open book question answering, 2018.

Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. In Indian Conference on Computer Vision, Graphics and Image Processing , Dec 2008.

Zelin Peng, Zhengqin Xu, Zhilin Zeng, Xiaokang Yang, and Wei Shen. Sam-parser: Fine-tuning sam efficiently by parameter space reconstruction. Proceedings of the AAAI Conference on Artificial Intelligence , 38:4515-4523, 03 2024.

Zeju Qiu, Weiyang Liu, Haiwen Feng, Yuxuan Xue, Yao Feng, Zhen Liu, Dan Zhang, Adrian Weller, and Bernhard Schölkopf. Controlling text-to-image diffusion by orthogonal finetuning. In Thirty-seventh Conference on Neural Information Processing Systems , volume 36, pages 79320-79362, 2023.

Colin Raffel, Noam Shazeer, Adam Roberts, Katherine Lee, Sharan Narang, Michael Matena, Yanqi Zhou, Wei Li, and Peter J. Liu. Exploring the limits of transfer learning with a unified text-to-text transformer. Journal of Machine Learning Research , 21(140):1-67, 2020.

Baptiste Rozière, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, Jérémy Rapin, Artyom Kozhevnikov, Ivan Evtimov, Joanna Bitton, Manish Bhatt, Cristian Canton Ferrer, Aaron Grattafiori, Wenhan Xiong, Alexandre Défossez, Jade Copet, Faisal Azhar, Hugo Touvron, Louis Martin, Nicolas Usunier, Thomas Scialom, and Gabriel Synnaeve. Code llama: Open foundation models for code, 2024.

Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An adversarial winograd schema challenge at scale, 2019.

Maarten Sap, Hannah Rashkin, Derek Chen, Ronan LeBras, and Yejin Choi. Socialiqa: Commonsense reasoning about social interactions, 2019.

Yanpeng Sun, Qiang Chen, Xiangyu He, Jian Wang, Haocheng Feng, Junyu Han, Errui Ding, Jian Cheng, Zechao Li, and Jingdong Wang. Singular value fine-tuning: Few-shot segmentation requires few-parameters fine-tuning. In Advances in Neural Information Processing Systems , volume 35, pages 37484-37496, 2022.

Gemma Team, Thomas Mesnard, Cassidy Hardin, Robert Dadashi, Surya Bhupatiraju, Shreya Pathak, Laurent Sifre, Morgane Rivière, Mihir Sanjay Kale, Juliette Love, et al. Gemma: Open models based on gemini research and technology. arXiv preprint arXiv:2403.08295 , 2024.

Ihsan Ullah, Dustin Carrion, Sergio Escalera, Isabelle M Guyon, Mike Huisman, Felix Mohr, Jan N van Rijn, Haozhe Sun, Joaquin Vanschoren, and Phan Anh Vu. Meta-album: Multidomain meta-dataset for few-shot image classification. In Thirty-sixth Conference on Neural Information Processing Systems Datasets and Benchmarks Track , 2022.

Yeming Wen and Swarat Chaudhuri. Batched low-rank adaptation of foundation models. In The Twelfth International Conference on Learning Representations , 2024.

Longhui Yu, Weisen Jiang, Han Shi, Jincheng Yu, Zhengying Liu, Yu Zhang, James T. Kwok, Zhenguo Li, Adrian Weller, and Weiyang Liu. Metamath: Bootstrap your own mathematical questions for large language models, 2023.

Rowan Zellers, Ari Holtzman, Yonatan Bisk, Ali Farhadi, and Yejin Choi. Hellaswag: Can a machine really finish your sentence? In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics , 2019.

Jingqing Zhang, Yao Zhao, Mohammad Saleh, and Peter Liu. PEGASUS: Pre-training with extracted gap-sentences for abstractive summarization. In Proceedings of the 37th International Conference on Machine Learning , volume 119 of Proceedings of Machine Learning Research , pages 11328-11339. PMLR, 13-18 Jul 2020.

Qingru Zhang, Minshuo Chen, Alexander Bukharin, Pengcheng He, Yu Cheng, Weizhu Chen, and Tuo Zhao. Adaptive budget allocation for parameter-efficient fine-tuning. In The Eleventh International Conference on Learning Representations , 2023.

Appendix

The appendix is organized as follows.

In Appendix A, we give proofs for the lemmas outlined in 3.2.

In Appendix B, we compare how the trainable parameters count for different PEFT techniques (LoRA, DoRA, VeRA) versus our method SVFT.

In Appendix C, we describe results for additional experiments and provide implementation details for all the experiments.

A Proofs

We provide brief proofs for the Structure , Expressivity and the Rank lemmas for SVFT:

(a) Structure: If M is diagonal, then the final matrix W 0 + U M V T can be written as U (Σ + M ) V T since W 0 = U Σ V T , where (Σ + M ) is also a diagonal matrix. Thus, U (Σ + M ) V T is a valid and unique SVD of W 0 + U M V T up to sign flips in the singular vectors.

(b) Expressivity: Finding M for any target matrix P of size d 1 × d 2 such that P = W 0 + U M V T is the same as finding M for a new target matrix P ′ = P -W 0 such that P ′ = U M V T . For a full SVD, the dimension of M is d 1 × d 2 and since the dimension of P ′ is also d 1 × d 2 , P ′ = U M V T is a bijection and M = U T ( P -W 0 ) V (since U and V are orthogonal).

(c) Rank: If M has k non-zero elements, then the rank of the update U M V T will be upper bounded by k (since by Gaussian elimination, k or less elements will remain, the best case being all k elements in the diagonal). We also know that the rank is upper bounded by min { d 1 , d 2 } , giving an achievable upper bound on the rank as min { k, min { d 1 , d 2 }} .

B Parameter Count Analysis

C Additional Experiments and Implementation Details

All of our experiments are conducted on a Linux machine (Debian GNU) with the following specifications: 2 × A100 80 GB, Intel Xeon CPU @ 2.20GHz with 12 cores, and 192 GB RAM. For all our experiments (including baseline experiments), we utilize hardware-level optimizations like mixed weight precision (e.g., bfloat16) whenever possible.

C.1 Comparison against SVD-based Variants

We compare SVF [31] and our proposed method, SVFT, on the GSM-8K and MATH benchmarks using Gemma-2B. The results are presented in Table 9. The results indicate that SVF and SVFT P exhibit comparable performance on these benchmarks, as expected due to their design equivalence. This

finding also applies to SVDiff [10] and SAM-parser [25] for the same reason. Additionally, the table highlights a significant performance improvement when comparing SVF to SVFT R , demonstrating the advantage of learning the off-diagonal elements.

C.2 Performance Evaluation with Fixed Target Module Adaptation

Wecompare SVFT to baseline methods, adapting the same target modules to ensure a consistent evaluation. Results are presented in Table 10, showing that SVFT outperforms other methods in this setup.

C.3 Commonsense Reasoning Gemma-2B

We evaluate and compare SVFT variants against baseline PEFT methods on commonsense reasoning tasks with Gemma-2B model and tabulate results in Table 11.

C.4 Are All Singular Vectors Important?

To determine the importance of considering all singular vectors and singular values during finetuning, we reduce the rank of U and V , and truncate Σ and M to an effective rank of r . If the original weight matrix W ∈ R m × n , then after truncation, U ∈ R m × r , V ∈ R n × r . This truncation significantly reduces the number of trainable parameters, so we compensate by increasing the number of off-diagonal coefficients ( d ) in M .

Our results, with four different configurations of r and d , are presented in Table 12. The findings show that a very low rank ( r = 128 ) leads to poor performance, even when parameters are matched. A reasonably high rank of r = 1536 , which is 75% of the full rank, still fails to match the performance of the full-rank variant that has 0.25 × the trainable parameters. This indicates that all singular vectors significantly contribute to the end task performance when fine-tuning with SVFT, and that important information is lost even when truncating sparingly.

C.5 Additional Memory Analysis Experiments

We present additional memory analysis experiments for Gemma-2B and LLaMA-3-8B in Table 13 and Table 14. SVFT variants consume lesser memory than DoRA and 1 . 2 × more memory than LoRA.

C.6 Performance vs Total Trainable Parameters

In addition to the experiments performed in Figure 1 (main paper) for Gemma-2B on challenging natural language generation (NLG) tasks like GSM-8K and Commonsense Reasoning, we also plot the performance vs total trainable parameters for larger state-of-the-art models like Gemma-7B and LLaMA-3-8B on GSM-8K. Figure 5 further demonstrates SVFT's pareto-dominance. On larger models, we observe that full-finetuning overfits, leading to sub-optimal performance in comparison to PEFT methods.

0.5

0.75

1.2

2

3

5

8

12.5

20

32

50

84

Number of Trainable Params (M)

70

71

72

73

74

75

76

77

78

SVFT

P

SVFT

B

d

=2

SVFT

R

d

=16

DoRA

r

=16

DoRA

r

=4

LoRA

r

=32

LoRA

r

=1

DoRA

r

=1

VeRA

r

=1024

BOFT

m

=2

b

=8

LoRA

r

=4

Full Fine-Tuning (8500M params)

Accuracy (%)

SVFT

P

BOFT

LoRA

r

=1

m

b

Full Fine-Tuning (2500M params)

VeRA

r

=1024

0.5

0.75

1.2

2

3

5

8

12.5

20

=12

DoRA

LoRA

r

r

=16

32

Number of Trainable Params (M)

C.7 Settings for Language Tasks

Natural Language Understanding. We fine-tune the DeBERTaV3base [11] model and apply SVFT to all linear layers in every transformer block of the model. We only moderately tune the batch size, learning rate, and number of training epochs. We use the same model sequence lengths used by [20] to keep our comparisons fair. The hyperparameters used in our experiments can be found in Table 15.

Natural Language Generation. See the hyperparameters used in our experiments in Table 16. For LoRA, DoRA, we adapt Q,K,V,U,D matrices. We apply BOFT on Q,V matrices since applying on multiple modules is computationally expensive. For VeRA, which enforces a constraint of uniform internal dimensions for shared matrices, we apply on G,U projection matrices as it yields the highest number of learnable parameters. We apply SVFT on Q,K,V,U,D,O,G for the Gemma family of models, and U, D, O, G for LLaMA-3-8B. Note that applying SVFT on these modules does not increase trainable parameters at the same rate as applying LoRA or DoRA on them would. We adopt the code base from https://github.com/meta-math/MetaMath.git for training scripts and

50

80

78

76

74

72

70

68

66

64

62

LoRA

r

SVFT

B

d

=2

=1

DoRA

r

SVFT

B

d

SVFT

B

d

=4

=2

=8

=8

=32

81

evaluation setups and use the fine-tuning data available at https://huggingface.co/datasets/ meta-math/MetaMathQA-40K .

Commonsense Reasoning. See the hyperparameters used in our experiments in Table 17. We adopt the same set of matrices as that of natural language generation tasks. We use the code base from https://github.com/AGI-Edgerunners/LLM-Adapters , which also contains the training and evaluation data.

C.8 Settings for Vision Tasks

For each dataset in the vision tasks, we train on 10 samples per class, using 2 examples per class for validation, and test on the full test set. Similar to previous literature, we always train the classifier head for these methods since the number of classes is large. The parameter counts do not include the number of parameters in the classification head. The hyperparameters are mentioned in Table 18. We tune the learning rates for SVFT and BOFT select learning rates for other methods from [17], run training for 10 epochs, and report test accuracy for the best validation model. For all methods, since the classification head has to be fully trained, we report the parameter count other than the classification head.

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 claims made in the abstract and introduction are motivated using extensive experiments (see section 4). A Lemma and its proof are introduced where required. We include some limitations of our work in the Limitations section (see section 6).

2. Limitations

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

Answer: [Yes]

Justification: We run extensive experiments on a range of models to study and analyze our method's performance. See section 6 for some limitations. We include parameter count analysis in Appendix B.

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 introduce our Lemma in subsection 3.2 and its corresponding proof in Appendix A.

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 our method description in section 3, experimental evaluation in section 4 and hyper-parameter ranges in Appendix C. Additionally, we provide code and scripts to replicate our experiments as part of supplementary material to provide more details.

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: Our code is publicly available at https://github.com/vijaylingam95/ svft - also referenced in our abstract. We include all details on hyper-parameters ranges and methods in Appendix C. All our experiments are run on publicly available datasets. We provide references to the dataset source in our code.

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: We provide details on our method in section 3. We provide comprehensive details on hyper-parameter ranges and datasets/model names in Appendix C. Additional details on model implementation and experiments are available in the code submitted as part of supplementary material. We rely on public datasets, splits, and evaluation strategies from previously published literature. We refer and cite these works in section 4.

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: Since we experiment with large models, it is often difficult to run these experiments with multiple seeds and report error bars. We follow the same setup from previously published research - these research works also do not compute error bars or report them in any of their results tables. E.g, DoRA: Weight-Decomposed Low-Rank Adaptation (ICML 2024 Accepted paper). Our limited compute resources have hindered us from running multiple seed experiments.

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 use a Linux machine (Debian GNU/Linux 10) with the following configuration: 2x A100 80GB, 192GB RAM, Intel Xeon CPU @ 2.20GHz with 12 cores. Here are some more information on the compute time for our language experiments: 2B models take around 6 hours and 7B/8B models take around 14 hours for training. For vision experiments using vision transformers (ViTs), it takes up to 4 hours for training.

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: We follow and abide by the ethics guidelines laid out by NeurIPS. We also preserve and conform to anonymity policies.

10. Broader Impacts

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

Answer: [Yes]

Justification: See section 6. Our work can allow more easy personalization of foundational models which can have both positive and negative societal impact. This is because our method provides computational efficiency (smaller memory footprint), making it less expensive to enable personalization.

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: [NA]

Justification: To the best of our knowledge, the paper poses no such risks on safeguards.

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 the original papers for utilizing the assets like code (in supplementary material), datasets (subsection 4.2, and models (subsection 4.1) including their appropriate versions. We also abide by different licenses for code bases, models, and datasets used in our work like CC, MIT, META LLAMA 3 COMMUNITY LICENSE AGREEMENT, Gemma Terms of Use, and more.

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 provide assets in the form of code and multiple scripts as a part of the supplementary material for the experiments and ablations performed in the paper. The details about model training, their respective hyperparameters, and limitations are furnished in section 4, Appendix C, and section 6 respectively. We also add the appropriate licenses for disseminating our assets, particularly code and scripts in the supplementary material.

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: The paper does not involve crowdsourcing, nor research with 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: The paper does not involve crowdsourcing, nor research with human subjects.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\n- Proposes method for parameter efficient fine-tuning using Singular Value Decomposition of the pretrained weights\n- Fine-tuning is done by adding a learned residual $\\Delta W = UMV^\\top$, where $M$ is a sparse trainable matrix, which results in fine-tuned weigts $\\hat{W} = U\\Sigma V^\\top + UMV^{\\top}$\n- Proposes 4 variants for sparsity: 1) Plain: $M$ is a diagonal matrix 2) Banded: the off-diagonal elements of $M$ are non-zero in a banded pattern 3) Random: Randomly selects $k$ elements of $M$ to be non-zero 4) Top-k: Selects tok $k$ elements for which the alingement between left and rght eigenvectors is the highest\n- Provides theoretical insights on the properties of the method concerning the structure, expressivity and rank of the fine-tuning residuals\n\nSTRENGTHS:\n1. The idea of using SVD of the pretrained weights for parameter efficient fine-tuning is interesting.\n2. The number of trainable parameters increases at a lower rate than LoRA/DoRA if more layers are adapted.\n3. Provides theoretical insights on the properties of the method concerning the structure, expressivity and rank of the fine-tuning residuals\n4. Shows better performance compared to VeRA, which suggests that SVFT is better for reducing the number of trainable parameters that the random parameters of VeRA (at the cost of higher memory usage). It also does not have a restriction of requiring same dimensions across layers like VeRA.\n5. Observation that truncating the singular vectors leads to loss of performance in Appendix C.3 is interesing and informative.\n5. The code is provided for verification.\n\nWEAKNESSES:\n1. **Missing citation and comparison with prior work**:\n    1) The proposed method is very similar to [1], which has not been cited. [1] fine-tunes the singular values (rather than a residual addition) for few shot semantic segmentation tasks. Given how closely related SVFT $^P$ is to [1] (even though the original work was in context of segmentation methods), a comparison should be performed on the benchmarks in this paper. This work is different enough, and does show additional insights, but a comparison should be performed for completeness.\n2. **Clarity and coherence of writing**:\n    1) In Table 3 (NLU experiments on GLUE), the paper mentions that the results fo some baseline methods are obtained from prior works, but does not cite the actual works that the results are obtained from\n    2) The paper mentions the components chosen for adaptation for SVFT (in the Appendix) but does not mention anything about the baseline methods. This makes it hard for a reader to know the details of the implementation up front, and also makes the comparison between the methods difficult.\n    3) On lines 14, 15, 16 and lines 46, 47, 48, the exact benchmark and model that generate these results should be mentioned - otherwise it's difficult to follow the paper.\n    4) The weight types adapted for each benchmark is different, and is not consistently mentioned in the main text, which makes it hard to follow the paper.\n3. **Increased memory usage during training**\n    1) While it's a positive that SVFT can keep the parameter count down while adapting more weight types, this will come at the cost of increased memory requirements.\n    2) The advantage of reducing the parameters is a reduction in the memory usage due to the gradients (first and second order moments in case of AdamW). It might be possible that the actual memory usage is still comparable to LoRA if only a small number of layers are adapted (this can be verified by checking the actual memory allocated on the GPU during training) given that the modules chosen for adaptation are the same. However, if SVFT requires more weight types to be fine-tuned than LoRA/DoRA, the memory usage will be higher even if the number of parameters is lower. Hence, for all the methods, the actual memory usage must be reported for the chosen weight types the methods are applied to.\n4. **Inconsistencies in evaluations**:\n    1) Natural Language Generation: For LoRA and DoRA, Q,K,V,U,D matrices are adapted (which is inline with [3]). However, for SVFT, Q,K,V,U,D,O,G are adapted for the Gemma family of models, and U,D,O,G for LLaMA-3-8B. This means that the performance cannot be attributed to the method rather than the choice of weight types adapted.\n    2) To decouple the choice of weight types adapted from the method, a comparison with LoRA and DoRA should be performed by adapting the same weight types. The performance of SVFT when Q,K,V,U,D are adapted for all the models must be compared with LoRA and DoRA.\n    3) Relating to the point above, for SVFT, why are U,D,O,G adapted for for Llama 3-8B and Q,K,V,U,D,O,G for Gemma on the Math benchmark?\n    4) With these inconsistent evaluation choices, the effectiveness, advantages and disagvantages of the method are not clear. If SVFT works better than baselines for certain components and not others, the paper should reflect this - and also show the memory required when using the weight types chosen for the respective methods.\n5. **The results on Vision tasks are confusing**:\n    1) The results with ViT-B and ViT-L in the main text are with different benchmarks (with ViT-B: CIFAR100 and Flowers102, and with ViT-L: Food101 and Resisc45). \n    2) On closer inspection of Table 9 in the Appendix, SVFT variants perform worse than LoRA and DoRA on Resisc45 with ViT-B, and marginally better on Food101. This suggests that SVFT is not as effective as LoRA and DoRA on some benchmarks even though it reduces the parameters. This should be mentioned in the main text.\n    3) The paper replicates the settings used in [2]. However, [2] adapts the Q and V layers for LoRA, which results in a high performance at a much lower parameter cost (comparison in the Table below, taken from this submission, and from [2]) than what the authors report with their implementation of LoRA applied to all linear layers. This can mean two things:\n        1) The training data/checkpoints are different, which can cause a difference in performance\n        2) Tuning all the linear layers is not a good idea for LoRA based on these results and [2], and is not indicative of LoRA's actual performance which makes the comparison unfair\n    4) To have a proper comparison with baselines, the above two points need to be disambiguated by testing how LoRA performs by adapting Q and V with the training data used by the authors for this submission. The arguments made for NLG in point 4 are also applicable here.\n\n\n| Method     | #Params | CIFAR100 | Flowers102 | Food101 | Resisc45 | #Params | CIFAR100 | Flowers102 | Food101 | Resisc45 |\n|------------|---------|----------|------------|---------|----------|---------|----------|------------|---------|----------|\n|            |         | ViT-B    |            |         |          |         | ViT-L    |            |         |          |\n| LoRA $_{r=8}$ | 1.32M   | 84.41    | 99.23      | 76.02   | 76.86    | 0.35M   | 86.00    | 97.93      | 77.13   | 79.62    |\n| DoRA $_{r=8}$ | 1.41M   | 85.03    | 99.30      | 75.88   | 76.95    | 3.76M   | 83.55    | 98.00      | 76.41   | 78.32    |\n| LoRA $_{r=1}$ | 0.16M   | 84.86    | 96.88      | 73.35   | 76.33    | 0.44M   | 85.97    | 98.28      | 75.97   | 78.02    |\n| DoRA $_{r=1}$ | 0.25M   | 84.46    | 99.15      | 74.80   | 77.06    | 0.66M   | 84.06    | 98.11      | 75.90   | 78.02    |\n| VeRA       | 24.6K   | 83.38    | 98.59      | 75.99   | 70.43    | 61.4K   | 86.77    | 98.94      | 75.97   | 72.44    |\n| SVFT $^{P}$    | 18.5K   | 83.85    | 98.93      | 75.68   | 67.19    | 49.2K   | 86.74    | 97.56      | 75.95   | 71.97    |\n| SVFT $_{d=2}$ | 0.28M   | 84.72    | 99.28      | 75.64   | 72.49    | 0.74M   | 86.59    | 98.24      | 77.94   | 79.70    |\n| SVFT $^{B=4}_{d=4}$ | 0.50M   | 83.17    | 98.52      | 76.54   | 66.65    | 1.32M   | 87.10    | 97.71      | 76.67   | 71.10    |\n| SVFT $_{d=8}$ | 0.94M   | 85.69    | 98.88      | 76.70   | 70.41    | 2.50M   | 87.26    | 97.89      | 78.36   | 73.83    |\n| From [2]           |         | ViT-B    |            |         |          |         | ViT-L    |            |         |          |\n| LoRA $_{r=8}$ | 0.294M   | 85.9    | 98.8      | 89.9   | 77.7    | 0.786M   | 87.00    | 99.91      | 79.5   | 78.3    |\n| VeRA       | 24.6K   | 84.8    | 99.0     | 89.0   | 77.0    | 61.4K   | 87.5    | 99.2      | 79.2   | 78.6    |\n\n\nFollowing studies are needed to verify the effectiveness of the method:\n1) A comparison with [1] (I would expect this to perform similar to SVFT $^P$, and any one benchmark, say Math, should be enough to verify this).\n2) Reporting the memory usage - Point 3 in Weaknesses\n2) Ablation study for point 4 (ii) in Weaknesses.\n3) Verification for point 5 (iii) in Weaknesses.\n\n**References**:\n\n[1] Yanpeng Sun, Qiang Chen, Xiangyu He, Jian Wang, Haocheng Feng, Junyu Han, Errui Ding, Jian Cheng, Zechao Li, Jingdong Wang: Singular Value Fine-tuning: Few-shot Segmentation requires Few-parameters Fine-tuning. NeurIPS 2022\n\n[2] Dawid Jan Kopiczko, Tijmen Blankevoort, Yuki Markus Asano: VeRA: Vector-based Random Matrix Adaptation. ICLR 2024\n\n[3] Shih-Yang Liu, Chien-Yi Wang, Hongxu Yin, Pavlo Molchanov, Yu-Chiang Frank Wang, Kwang-Ting Cheng, Min-Hung Chen: DoRA: Weight-Decomposed Low-Rank Adaptation. ICML 2024\n\nQUESTIONS:\n1. In Figure 1, which weight types are adapted for each method?\n2. For Natural Language Generation tasks, why is SVFT applied to Q,K,V,U,D,O,G for the Gemma family of models, and U,D,O,G for LLaMA-3-8B?\n3. For Math and Commonsense reasoning tasks, what are the training, validation and test splits used, and on which split are the hyperparameters tuned?\n4. For visual classification tasks, why is LoRA and DoRA applied to all the linear layers instead of Q and V as done in the original VeRA paper [2], which shows better performance at a much lower parameter cost? Is the training data from the same, or different even if the number of samples per class are the same?\n    - The performance reported in [2] for VeRA is higher than that reported in this submission (the discrepancy with ViT-B for Food101 is particularly high). What is the cause of this?\n\nLIMITATIONS:\nAuthors have addressed the limitations.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-06-17"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors propose a parameter-efficient fine-tuning method with singular vectors (SVFT). SVFT modifies the parameter matrix based on the structure of the original parameter matrix $\\mathbf{W}$. By training the coefficient of a sparse combination of outer products of $\\mathbf{W}$'s singular vectors, SVFT recovers up to 96% of full fine-tuning performance while training 0.006 to 0.25% of the parameter.\n\nSTRENGTHS:\nIt is a simple approach that should be easy to reproduce.\n\nWEAKNESSES:\nOverstatement: the authors fine-tune the coefficient of the original parameter matrix $\\mathbf{W}$'s singular vectors to achieve that fine-grained control over expressivity, which is good - but practically this is still similar to the existing methods. Stating in the abstract that \\`\\` We propose SVFT, a simple approach that fundamentally differs from existing methods: the structure imposed on $\\Delta \\mathbf{W}$ depends on the specific weight matrix $\\mathbf{W}$ .\\'\\' suggests more extensive comparison with existing methods as well. \n\n[1] Peng, Zelin, et al. SAM-PARSER: Fine-Tuning SAM Efficiently by Parameter Space Reconstruction, AAAI 2024.\n\n[2] Han, Ligong, et al. SVDiff: Compact Parameter Space for Diffusion Fine-Tuning, ICCV 2023.\n\nI could not find the comparison of $\\text{SVFT}_P$, $\\text{SVFT}_B$, $\\text{SVFT}^R_d$ and $\\text{SVFT}^T_d$ in Tables 1-4. At the moment it's unclear how to choose the sparsity pattern $\\Omega$.\n\nQUESTIONS:\nif $\\text{SVFT}^{R}_{d=2}$, $k=?$ \n\nif $\\text{SVFT}^{T}_{d=2}$, $k=?$\n\nWhat is the purpose of proposing $\\text{SVFT}^T_d$ if it has not shown any performance advantage in any experiment?\n\nHow to choose the appropriate sparsity pattern $\\Omega$?\n\nFor model performance, does randomness in $\\text{SVFT}^T_d$ lead to instability?\n\nLIMITATIONS:\nYes.", "TITLE": "Official Review", "RECOMMENDATION": 3, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2024-07-10"}

comments: SUMMARY:
This paper presents a new PEFT method to enhance the fine-tuning efficiency of large language models (LLMs). The approach uses SVD to decompose pre-trained weights, initializing adapters with eigenvectors and eigenvalues, and adjusts within the eigenvalue space. Extensive experiments show that the proposed method requires fewer parameters while achieving performance that matches or exceeds other PEFT methods.

STRENGTHS:
The paper is well-written and easy follow. The motivation is clear, the method is straightforward, and it has been evaluated on mainstream tasks in both NLP and CV fields.

WEAKNESSES:
1. Introducing the M matrix indeed allows for more ways to modify eigenvalues, but the paper does not discuss the differences and advantages between directly fine-tuning the SVD eigenvalue space and the proposed method.
2. Decomposing the pre-trained weights directly results in a significant increase in the number of parameters during training, leading to much higher training costs compared to methods like LoRA. This is the main drawback of fine-tuning the eigenvalue space.
3. The approach of fine-tuning the singular value space after SVD decomposition of pre-trained weights is not novel. The paper lacks a summary of such methods, such as [1] Singular value fine-tuning: Few-shot segmentation requires few-parameters fine-tuning and [2] Svdiff: Compact parameter space for diffusion fine-tuning.

QUESTIONS:
same as weaknesses

LIMITATIONS:
This paper does not reflect any potential negative societal impact.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2024-07-10

comments: SUMMARY:
This paper proposes a parameter-efficient fine-tuning (PEFT) method named SVFT. Instead of imposing learnable parameters directly on the pre-trained weight matrices, it applies singular value decomposition to the pre-trained weight matrices and then tunes only the coefficients of the singular values. The method is validated on various vision/language tasks, showing comparable or better performance compared to multiple existing PEFT methods.

STRENGTHS:
* The paper is well-written and easy to follow
* The method is novel. Studying the behavior of SVFT in more depth can be beneficial to the PEFT community.
* On both language and vision tasks, SVFT shows comparable or better performance than LoRA, DoRA, VERA, and BOFT, demonstrating the efficacy of the method.

WEAKNESSES:
* The comparison between VeRA and $\text{SVFT}^P$ is interesting. Design-wise, they are quite similar, yet $\text{SVFT}^P$ leads to much better performance than VeRA in most cases, even though VeRA has a larger intermediate dimension (e.g., Table 2). I wonder if the authors can elaborate more on this matter.
* In many cases, $d=2$ seems to be sufficient for $\text{SVFT}^B$. However, increasing $d$ for $\text{SVFT}^B$ does not necessarily improve performance (e.g., Table 4 in the main paper or Table 9 in the appendix). How should we interpret this, and how should we select the suitable $d$ in practice?
* What advice do the authors have for choosing between $\text{SVFT}^B$ and $\text{SVFT}^R$? They seem to have comparable performance on different benchmarks.

QUESTIONS:
See Weaknesses

LIMITATIONS:
NA
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2024-07-11