SVFT: Parameter-Efficient Fine-Tuning with Singular Vectors

Authors: vijay  lingam
atula  tejaswi
aditya  vavre
aneesh  shetty
krishna  gautham
  gudur
joydeep  ghosh
alex  dimakis
eunsol  choi
aleksandar  bojchevski
sujay  sanghavi
Venue: ICML_cc_2024_Workshop_WANT
Published: 2024-05-26 00:47:22

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 show a performance gap compared to full fine-tuning. Although recent PEFT methods have narrowed this gap, they do so at the cost of additional learnable parameters. 
We propose SVFT, a simple approach that fundamentally differs from existing methods: the structure imposed on \(\mathbf{\Delta W}\) depends on the specific weight matrix \(\mathbf{W}\). Specifically, SVFT updates \(\mathbf{W}\) as a sparse combination of outer products of its singular vectors, training only the coefficients (scales) of these sparse combinations. This approach allows fine-grained control over expressivity through the number of coefficients. Extensive experiments on language and vision benchmarks show that SVFT recovers up to \textbf{96\%} of full fine-tuning performance while training only \textbf{0.006 to 0.25\%} of parameters, outperforming existing methods that only recover up to \textbf{85\%} performance using \textbf{0.03 to 0.8\%} of the trainable parameter budget.

Main paper: 
 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 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 Top-k 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. 
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 + ∆W x = 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 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 W0+∆W ∥W0+∆W ∥c x = m W0+BA ∥W0+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. 
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. We now formally describe our method, SVFT for parameter-efficient fine-tuning of a pre-trained model. Let W 0 ∈ R d1×d2 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 = U M V 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,EQUATIONWe 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. Top-k 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 top-k 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 top-k 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.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 + U M V 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 + U M V 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 matrixW 0 + U M V T .(b) Expressivity: Given any target matrix P of size d 1 × d 2 , there exists an M such thatP = W 0 + U M V 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 U M V 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:EQUATIONwhere 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.∆W LoRA = r i=1 a i b i T and ∆W VeRA = r i=1 α i (â i ⊙ β) bT i (3)where a i and b j are the trainable columns of A and B matrices in LoRA. In VeRA, âi and bi 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 âi or bi 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, âi , bi 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. 
base models & setup: 
 We adapt widely-used language models, encoder-only model (DeBERTaV3 base [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] . 4Target 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.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 
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 Table 4 : Performance on image classification benchmarks -CIFAR-100 (C100), Food101 (F101), Flowers102 (F102), and Resisc-45 (R45). We only adapt Q, V matrices for all methods, following prior work [17] . We report accuracy for all tasks. 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. 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 = 8Figure 4 : Performance variation with SVFT B d based on the adapted weight matrices -GSM-8K with Gemma-2B. Adapting more target weight types results in greater gains in performance. Interestingly, for a fixed parameter budget, adapting U and D weight types gives greater lifts than adapting Q and V .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.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%. Additionally, it's important to note that in these vision experiments, both classifier head parameters and other learnable parameters are trained.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.Table 5 : GPU Memory analysis, measured in gigabytes (GB). We report the average performance on GSM-8K and MATH. SVFT outperforms both LoRA and DoRA in terms of performance while requiring lesser GPU memory than DoRA.Target Modules Gemma-2B Gemma-7B#Params GPU Mem Perf. #Params GPU Mem Perf. EQUATIONIn 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.8M ). Our findings indicate that adapting more weight types enhances performance. We analyze the impact of various parameterizations of M (Plain, Banded, Random, Top-k) 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.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. 
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. 
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.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. 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. 
 
 Appendix: 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. 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. Natural Language Understanding. We fine-tune the DeBERTaV3 base [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 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.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.Learnable parameters are underlined.BOFT is approximately three times slower than LoRA. The shared matrices in VERA can become a limiting factor for models with non-uniform internal dimensions, such as LLaMA-3. 


Decision: All reviewers champion the acceptance of this manuscript, given its well-motivated methodology, good paper writing quality, extensive empirical results, and thorough ablation study on various CV and NLP tasks.