Pith. sign in

REVIEW 5 major objections 7 minor 51 references

HydraOpt: Navigating the Efficiency-Performance Trade-off of Adapter Merging

T0 review · 5 major / 7 minor · reviewed 2026-08-15 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read HydraOpt merges many LoRA adapters into one shared A-matrix plus a few task-specific B-matrices, cutting storage by 48% while keeping average accuracy within 1.8% of the unmerged adapters.

desk verdict HydraOpt is a genuinely new tunable adapter-merging scheme with a broad, honest evaluation, but the abstract overstates the headline retention and a softmax inconsistency needs fixing before publication. read the letter →

arxiv 2507.17706 v1 pith:RQJ2PS2Z submitted 2025-07-23 cs.LG

Taha Ceritli , Ondrej Bohdal , Mete Ozay , Jijoong Moon , Kyeng-Hun Lee , Hyeonmok Ko , Umberto Michieli This is my paper · ORCID
classification cs.LG
keywords modelmerginglow-rankadaptersLoRAparameter-efficientfine-tuningdata-freemultilingualtasksstoragereductionon-deviceLLMdeployment
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

Large language models that serve many specialized tasks usually keep one low-rank adapter per task, and that storage grows quickly on memory-limited devices. HydraOpt claims this overhead can be cut by exploiting an asymmetry observed in LoRA training: the $A$ matrices across tasks remain fairly similar while the $B$ matrices carry task-specific information. The paper's proposal is to fit a single shared $A'$ matrix and $M$ task-specific $B'$ matrices, with softmax coefficients assigning each task to a $B'$, so that the reconstructed products approximate the original adapter updates. On 40 tasks built from 5 applications and 8 languages, this yields a 48% storage reduction with only a 0.2–1.8% average performance drop, and it outperforms Task Arithmetic, TIES, DARE, and DARE-TIES once slightly more storage is allowed. The key contribution is a dial: choosing $M$ navigates the storage–accuracy frontier instead of accepting the fixed trade-off that one-shot merging methods impose.

What carries the argument

The machinery is a parameter-space reconstruction objective: HydraOpt minimizes $f(B_i A_i, \sum_j \sigma(C_i'/T)_j B_j' A')$ over a shared $A'$, $M$ task-specific $B'$ matrices, and trainable softmax coefficients $C_i'$, with $f$ chosen as mean absolute error to match the sparsity of adapter parameters. The softmax term approximates a one-hot assignment of tasks to $B'$ parameters, and the coefficients are discarded after training once each task is assigned a $B'$. This objective carries the argument because it converts model merging into an optimization problem whose storage cost is set explicitly by the single integer $M$.

What would settle it

Take one task's original LoRA adapter and add random noise to its $B$ matrix with the same L1 norm as HydraOpt's reconstruction error for that task; if the noisy adapter loses far more accuracy than the merged adapter, then parameter-space L1 error is not what preserves task behavior, and the reported accuracy retention would be specific to these tasks rather than a general property. A direct check is whether per-task reconstruction error predicts per-task accuracy loss across the 40-task grid.

Watch

Extended reading notes

Core claim

For a set of LoRA adapters with updates $\Delta W_i = B_i A_i$, HydraOpt claims that a reconstruction $\Delta W_i' = \sum_j \sigma(C_i'/T)_j B_j' A'$ with one shared $A'$ and $M$ task-specific $B'$ matrices can preserve task performance when the L1 distance between $\Delta W_i$ and $\Delta W_i'$ is minimized, with softmax coefficients selecting the $B'$ used by each task. When $M$ equals the number of tasks, the coefficients drop out and each task keeps its own $B'$. The method rests on the observed asymmetry that $A$ parameters initialized from the same distribution stay similar across tasks while $B$ parameters diverge, so the shared $A'$ captures common structure and the $B'$ matrices absorb task-specific detail. Empirically, merging five LoRA adapters with $M = 5$ stores about 52% of the original parameters (a 48% reduction) and averages 0.2–1.8% below the unmerged adapters across four LLMs, and the same recipe extends to VeRA adapters by sharing the $\Lambda_d'$ direction vectors. The paper concludes that this makes adapter merging a controllable efficiency–performance spectrum rather than a single fixed operating point.

Load-bearing premise

The method assumes that a small average absolute difference between the original and reconstructed adapter matrices means the merged adapter will still perform each task well; this is tested empirically throughout the paper but not proven analytically.

Editorial extensions

If this is right

  • At the same 20% storage as fixed baselines ($M = 1$), HydraOpt performs comparably to Task Arithmetic on English five-way merges, and with just 8% more storage ($M = 2$) it exceeds the best baseline by about 1.5 points on average.
  • With one $B'$ per task ($M = 5$), average scores approach the unmerged LoRA upper bound on all four tested LLMs, while storing roughly half the parameters.
  • The same shared-direction scheme works for VeRA adapters, reaching 36.4 average score at 22.7% storage compared with 27.8 for the best fixed-size baseline.
  • Merging across 40 tasks (5 applications × 8 languages), increasing storage from 20% to 28% raises average performance by about 2 points on Llama-1B and over 3 points on Llama-3B.
  • Across applications, languages, and the full task grid, the pattern is consistent: HydraOpt matches the best fixed-size method at minimum storage and widens the advantage as $M$ grows.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The same shared-subspace reconstruction could transfer to other adapter families whose initialization is asymmetric, provided the common $A$-direction remains stable as task diversity grows.
  • Because the coefficients are trained only on parameter distance, adding a small calibration set to refine the assignment or the $B'$ matrices is a natural data-driven extension; the paper explicitly leaves that direction open.
  • Storage savings grow with the number of adapters and exceed 50% when $A$ is larger than $B$, so the method's practical upside is largest in deployments with many adapters rather than just a handful.
  • The $M$-dial suggests a simple deployment rule the paper does not spell out: choose $M$ by measuring the marginal accuracy gained per additional $B'$ on a validation set, rather than treating the storage budget as a fixed constant.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 7 minor

Summary. The paper proposes HydraOpt, a data-free adapter-merging method that takes K low-rank adapter pairs (e.g., LoRA) and approximates them with one shared A' matrix and M task-specific B' matrices, minimizing an L1 parameter-space distance to the original updates ΔW_i = B_i A_i. The number M controls a storage-performance trade-off, and a softmax over learned coefficients C' selects which B' is used per task. The empirical study covers 5 applications x 8 languages (40 tasks), four LLMs, LoRA and VeRA, and rank ablations. The authors report that at the highest compression (M=1, 20% storage) HydraOpt is comparable to Task Arithmetic, while at higher M it approaches the unmerged LoRA upper bound; the abstract highlights a 48% storage reduction with only a 0.2-1.8% average performance drop, and claims consistent gains over TIES, DARE, and DARE-TIES when storage is allowed to increase.

Significance. If the findings hold, HydraOpt is a useful contribution to on-device LLM deployment: it is data-free, requires no task-specific samples, and offers a tunable storage-performance knob that existing merging methods lack. The evaluation is unusually broad for a merging paper (40 tasks, 8 languages, 4 model families, 2 adapter types, rank ablations) and the appendix includes full PyTorch-style code, which is a strength. The core optimization is straightforward and not circular: the original adapters are inputs, and evaluation is on held-out tasks. However, the significance is conditional on resolving several load-bearing issues: the headline accuracy claim omits the most difficult 40-task merging scenario, the reported storage percentages appear inconsistent with the paper's own parameter-count formula, the implementation's temperature handling disagrees with Eq. (1), and no error bars or multiple seeds are provided. Because the claimed advantages are on the order of 1-2% in average accuracy, the lack of variance estimates is a substantive concern, not a cosmetic one.

major comments (5)
  1. [Abstract and Table 4 (task block)] The abstract and Section 5 state a '0.2-1.8% drop' with a '48% storage reduction,' but Table 4 shows that merging all 40 tasks with HydraOpt(M=40) at S=41.5% incurs an average drop of 7.2% relative to LoRA (L1B: 21.9 vs 28.1; L3B: 25.2 vs 33.2; average 23.5 vs 30.7). The 0.2-1.8% range comes from the per-language 5-application setting, not from the full 40-task setting. This is a material overstatement of the method's general behavior and should be corrected or explicitly scoped in the abstract and conclusion.
  2. [Section 3.2 and Figures 7-9] The implementation of the objective is inconsistent with Eq. (1). Equation (1) defines the softmax argument as C'_i/T, and the text says small values approximate one-hot vectors. However, the code in Fig. 8 (line 31) computes softmax(C_primes * T) in hydra_loss, while Fig. 9 (line 54) uses softmax(C_primes / T) for the final B' mapping, and Fig. 7 (line 51) initializes C with softmax(randn / T). Because the temperature scaling changes the sharpness of the coefficient distribution (and therefore the gradient signal during training), the implemented objective is not the stated one. Please align Eq. (1), the code, and the mapping step, and report the temperature value used.
  3. [Section 3.2, Table 1, and Fig. 12] The storage percentages in Table 1 are inconsistent with the paper's own parameter-count formula. For K=5 and square A/B matrices (d=k), HydraOpt(M=5) requires (5d+k)/(5(d+k)) = 60% of the original LoRA parameters, not the reported S=52%; for M=2 the formula gives 30%, not 28%. The reported S values correspond to d/k = 2/3, which does not match the Llama-3.2-1B q/k/v/o projection shapes described in Section 4.1. Because the '48% storage reduction' headline depends on S=52, this discrepancy must be resolved: either the S values in Tables 1-4 and Figure 4 are wrong, or the parameter-count formula in Section 3.2 is missing a term. Please clarify and report exact parameter counts.
  4. [Tables 1-5 and Figure 4] All experiments appear to report a single run with no error bars, multiple seeds, or statistical significance tests. The paper's key claims are differences of 0.2-1.8% in average performance and a 1.5% gain over Task Arithmetic at 8% additional storage; without variance estimates these differences cannot be distinguished from evaluation noise. Please report at least three seeds with standard deviations (or confidence intervals) for the main tables and figures, and state whether the reported numbers are means or single runs.
  5. [Equations (1)-(2) and Section 4.2] The method's core assumption is that minimizing L1 distance between ΔW_i and B'_j A' in parameter space preserves downstream task accuracy. This is verified only indirectly through task performance; the paper does not report the achieved reconstruction error or analyze its correlation with downstream accuracy. Given that the 40-task merging result shows a 7.2% drop despite presumably low L1 error (the setting is the same reconstruction problem), the transfer from parameter error to task behavior is not automatic. Please report the final training loss / L1 reconstruction error for each setting and, if possible, a plot of reconstruction error versus task performance across M values.
minor comments (7)
  1. [Table 3] Task Arithmetic on VeRA reports an average of 0.3, far below the zero-shot baseline of 17.2 and all other methods; this value looks like an evaluation or implementation artifact and should be checked or explained.
  2. [Table 17] HydraOpt(M=5) has a runtime of 8.6 minutes, which is lower than HydraOpt(M=3) at 17.2 and HydraOpt(M=4) at 20.6; this is likely a typo and should be corrected.
  3. [Figure 4] The legend in Figure 4 uses 'HyperOpt' instead of 'HydraOpt' in several rows.
  4. [Section 4.1] The list of applications introduces both the fourth and fifth items as '(iv)'; the numbering should be fixed.
  5. [Section 3.2] The sentence 'the total number of parameters reduces to 60% when merging 5 pairs of LoRA parameters' is ambiguous because it applies only to the M=K case; please state this explicitly and reconcile it with the S values in Table 1.
  6. [Section 3.2] The temperature T is a free hyperparameter, but no sensitivity analysis or chosen value is reported in the main text. Please state the value of T used and, ideally, show its effect on performance.
  7. [Section 3.2] The phrase 'The softmax function approximates categorical one-hot encoded vectors for small values' is imprecise; the relevant limit is T approaching zero for σ(C/T), or large T for σ(C·T). Please clarify the intended scaling.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: HydraOpt optimizes a parameter-space reconstruction objective against the given adapters and evaluates on held-out tasks, so the central claim does not reduce to its inputs.

full rationale

The derivation chain is: (i) given K LoRA adapters B_i A_i, define an optimization objective (Eqs. 1-2) that minimizes the L1 distance between the original updates Delta-W_i and a reconstructed shared-A product; (ii) optimize A', B'_i, and C'_i; (iii) evaluate the merged adapters on downstream benchmarks. The objective's target is the input adapters, but that is precisely the intended optimization input, not a disguised prediction. The reported accuracy numbers are measured on tasks after merging, not computed from the optimization objective or from any fitted scalar whose value is reused as the result. The storage-efficiency figures come from a parameter-count identity (M*r*d + r*k versus K*r*(d+k)) and are not a circular prediction. The merging baselines (TA, TIES, DARE, DARE-TIES) are external algorithms supported by independent prior work, and the author self-citations that appear in related work and in the adapter-similarity motivation are not load-bearing for the central efficiency-performance claim. The paper explicitly acknowledges that data-free merging is upper-bounded by LoRA performance, and the parameter-space-to-task-performance transfer is an empirical assumption that could be questioned, but that is a correctness risk, not circularity. Similarly, the discrepancy between the paper's softmax-temperature notation and the code excerpt is a reproducibility concern, not a circular step. No load-bearing step reduces by construction or by a self-citation chain to its own inputs, so the paper receives a circularity score of 0.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The ledger shows the method's assumptions: shared-A similarity, parameter-space loss transfer, soft-to-hard rounding, and optimizer success. Free parameters are the training hyperparameters and the M knob. No new physical entities are introduced; A', B', C' are optimization variables, not invented entities.

free parameters (4)
  • softmax temperature T = 5.0
    Set in Figure 9 code (T=5.0). Controls how one-hot the task-to-B' assignment is during training. Paper Eq. (1) writes softmax(C/T), code uses softmax(C*T), an inconsistency.
  • learning rate = 0.01
    Used in hydraopt_merging (Figure 9); AdamW optimizer. No sensitivity analysis reported.
  • epochs E = 1000
    Training length in Figure 9; no convergence criterion or ablation on E.
  • number of task matrices M = 1..K (user-selected)
    The trade-off knob: M controls storage versus performance. Not fitted; it is the design variable that the method exposes.
assumptions (4)
  • domain assumption For LoRA and VeRA adapters fine-tuned on different tasks, the A matrices (or Lambda_d) are similar across tasks while B matrices (or Lambda_b) are task-specific.
    Motivates sharing A' across tasks; based on Fig. 2, Fig. 10-11, and cited work (Zhu et al. 2024, Tian et al. 2024). If false, the shared-A reconstruction has no basis.
  • domain assumption Minimizing L1 distance between original Delta_W_i and reconstructed B'_j A' is a sufficient proxy for preserving downstream task performance.
    The loss in Eq. (1)-(2) is parameter-space only; no task data is used and no bound or proof connects parameter error to task metrics.
  • domain assumption A hard argmax assignment at inference preserves the behavior learned with the soft assignment.
    Algorithm 1 rounds softmax coefficients to one-hot after training; the paper does not measure the soft-to-hard gap.
  • standard math Gradient descent with AdamW converges to a good solution of the non-convex joint factorization objective.
    No convergence guarantees are given; the paper relies on 1000 epochs of AdamW at lr=0.01.

how reviews work

0 comments
Cite this review

Pith. "Pith review of HydraOpt: Navigating the Efficiency-Performance Trade-off of Adapter Merging." pith.science (2026). https://pith.science/paper/RQJ2PS2Z

@misc{pith2026250717706,
  author       = {Pith},
  title        = {Pith review of: HydraOpt: Navigating the Efficiency-Performance Trade-off of Adapter Merging},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RQJ2PS2Z}},
  note         = {Machine review of arXiv:2507.17706}
}
read the original abstract

Large language models (LLMs) often leverage adapters, such as low-rank-based adapters, to achieve strong performance on downstream tasks. However, storing a separate adapter for each task significantly increases memory requirements, posing a challenge for resource-constrained environments such as mobile devices. Although model merging techniques can reduce storage costs, they typically result in substantial performance degradation. In this work, we introduce HydraOpt, a new model merging technique that capitalizes on the inherent similarities between the matrices of low-rank adapters. Unlike existing methods that produce a fixed trade-off between storage size and performance, HydraOpt allows us to navigate this spectrum of efficiency and performance. Our experiments show that HydraOpt significantly reduces storage size (48% reduction) compared to storing all adapters, while achieving competitive performance (0.2-1.8% drop). Furthermore, it outperforms existing merging techniques in terms of performance at the same or slightly worse storage efficiency.

Figures

Figures reproduced from arXiv: 2507.17706 by the authors.

Figure 1
Figure 1. Performance and storage efficiency trade￾off. Average performance over 5 applications and 8 languages. Existing merging techniques reduce stor￾age costs at significant performance drops. Our method performs similarly at the same efficiency level and im￾proves if more storage is available, achieving perfor￾mance similar to LoRAs. efficient fine-tuning (PEFT) (Hu et al., 2022; Xu et al., 2023; Lialin et al., 2023), wh… view at source ↗
Figure 2
Figure 2. Similarity between A and B matrices of LoRAs measured using Mean Absolute Error on query matrices of Llama-3.2-3B-Instruct fine-tuned on 5 ap￾plications in English. ℓ = X K i=1 f  BiAi , X M j=1 σ(C′ i/T)(j)B ′ jA ′   , (1) where f is a distance function that measures the similarity between two model updates ∆Wi := BiAi and ∆W′ j := B′ jA′ . Here, σ denotes the softmax function with the temperature term T, and C… view at source ↗
Figure 3
Figure 3. An overview of HydraOpt. We approximate K sets of LoRA parameters by learning a shared A′ parameter and a set of task-specific parameters {B′ i }M i=1. performance trade-off of model merging. In the most aggressive parameter sharing scheme, Hy￾draOpt constructs one set of LoRA parameters {B′ , A′}, which causes performance drops due to the reduced flexibility of the approximation simi￾larly to existing model merging… view at source ↗
Figures from the paper (9 more)
Figure 4
Figure 4. Figure 4: Average performance on 5 applications in different languages using Llama-3.2-1B-Instruct. In this figure, we report the relative average score com￾pared to LoRA. We performed the same 5-way merging experiment in multiple languages and we observe similar im￾provements a…
Figure 5
Figure 5. Figure 5: Impact of distance function used during training. We report average performance on 5 En￾glish applications using Llama-3.2-1B-Instruct LoRA￾finetuned. across the LoRA rank r ∈ {8, 16, 32}. As shown in [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Impact of storage efficiency level. We report average performance on 5 English applications using Llama-3.2-1B-Instruct LoRA-finetuned. Limitations Despite the encouraging results obtained using Hy￾draOpt, there are certain limitations in our current study that are wor…
Figure 7
Figure 7. Figure 7: Implementation of HydraOpt module [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]
Figure 8
Figure 8. Figure 8: Implementation of HydraOpt loss function [PITH_FULL_IMAGE:figures/full_fig_p013_8.png]
Figure 9
Figure 9. Figure 9: Implementation of HydraOpt merging [PITH_FULL_IMAGE:figures/full_fig_p014_9.png]
Figure 10
Figure 10. Figure 10: Similarity between A and B matrices of LoRAs measured using Canonical Correlation Analysis (CCA) goodness of fit as conducted by Zhu et al. (2024) on query matrices of Llama-3.2-3B-Instruct fine-tuned on English data [PITH_FULL_IMAGE:figures/full_fig_p015_10.png]
Figure 11
Figure 11. Figure 11: t-SNE plots using LoRA parameters for query matrices of Llama-3.2-3B-Instruct fine-tuned across 5 applications in English. Numbers indicate which layer the parameter comes from. Shapes/colors indicate the application the model is fine-tuned for. The differences in the…
Figure 12
Figure 12. Figure 12: The reduction in parameter size when using HydraOpt(M=K), assuming that the parameters A and B are the same size [PITH_FULL_IMAGE:figures/full_fig_p016_12.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

51 extracted references · 35 canonical work pages

  1. [1]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block STRING...

  2. [2]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

  3. [3]

    Marah Abdin, Jyoti Aneja, Hany Awadalla, Ahmed Awadallah, Ammar Ahmad Awan, Nguyen Bach, Amit Bahree, Arash Bakhtiari, Jianmin Bao, Harkirat Behl, and 1 others. 2024. Phi-3 technical report: A highly capable language model locally on your phone. arXiv preprint arXiv:2404.14219

    arXiv 2024

  4. [4]

    Francis Bach, Rodolphe Jenatton, Julien Mairal, Guillaume Obozinski, and 1 others. 2012. Optimization with sparsity-inducing penalties. Foundations and Trends in Machine Learning, 4(1):1--106

    work page 2012

  5. [5]

    Ashish Bastola, Hao Wang, Judsen Hembree, Pooja Yadav, Zihao Gong, Emma Dixon, Abolfazl Razi, and Nathan McNeese. 2023. LLM-based smart-reply (LSR): Enhancing collaborative performance with ChatGPT-mediated smart reply system . arXiv preprint arXiv:2306.11980

    arXiv 2023

  6. [6]

    Marco Bellagente, Jonathan Tow, Dakota Mahan, Duy Phung, Maksym Zhuravinskyi, Reshinth Adithyan, James Baicoianu, Ben Brooks, Nathan Cooper, Ashish Datta, and 1 others. 2024. Stable LM 2 1.6 B technical report . arXiv preprint arXiv:2402.17834

    arXiv 2024

  7. [7]

    Alexander Borzunov, Max Ryabinin, Artem Chumachenko, Dmitry Baranchuk, Tim Dettmers, Younes Belkada, Pavel Samygin, and Colin A Raffel. 2024. Distributed inference and fine-tuning of large language models over the internet. In NeurIPS

    work page 2024

  8. [8]

    Adriane Boyd, Jirka Hana, Lionel Nicolas, Detmar Meurers, Katrin Wisniewski, Andrea Abel, Karin Sch \"o ne, Barbora Stindlov \'a , and Chiara Vettori. 2014. The MERLIN corpus: Learner language and the CEFR. In LREC

    work page 2014

Show all 51 references
  1. [9]

    Christopher Bryant, Mariano Felice, istein E Andersen, and Ted Briscoe. 2019. The BEA-2019 shared task on grammatical error correction . In Workshop on innovative use of NLP for building educational applications

    2019

  2. [10]

    CJ Bryant, Mariano Felice, and Edward Briscoe. 2017. Automatic annotation and evaluation of error types for grammatical error correction. In ACL

    2017

  3. [11]

    Taha Ceritli, Savas Ozkan, Jeongwon Min, Eunchung Noh, Cho Jung Min, and Mete Ozay. 2024. A study of parameter efficient fine-tuning by learning to efficiently fine-tune. In EMNLP Findings, pages 15819--15836

    2024

  4. [12]

    Sauptik Dhar, Junyao Guo, Jiayi (Jason) Liu, Samarth Tripathi, Unmesh Kurup, and Mohak Shah. 2021. A survey of on-device machine learning: An algorithms and learning theory perspective. ACM Trans. Internet Things, 2(3)

    2021

  5. [13]

    Ning Ding, Yujia Qin, Guang Yang, Fuchao Wei, Zonghan Yang, Yusheng Su, Shengding Hu, Yulin Chen, Chi-Min Chan, Weize Chen, and 1 others. 2022. Delta tuning: A comprehensive study of parameter efficient methods for pre-trained language models. arXiv preprint arXiv:2203.06904

    2022 arXiv

  6. [14]

    Qingxiu Dong, Lei Li, Damai Dai, Ce Zheng, Jingyuan Ma, Rui Li, Heming Xia, Jingjing Xu, Zhiyong Wu, Baobao Chang, Xu Sun, Lei Li, and Zhifang Sui. 2024. A survey on in-context learning. In EMNLP

    2024

  7. [16]

    Arash Einolghozati, Anchit Gupta, Keith Diedrick, and Sonal Gupta. 2020. Sound natural: Content rephrasing in dialog systems. In EMNLP

    2020

  8. [17]

    Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, and 1 others. 2021. Beyond english-centric multilingual machine translation. Journal of Machine Learning Research, 22(107):1--48

    2021

  9. [18]

    Gemma Gemma Team. 2024. Gemma 2: Improving open language models at a practical size. arXiv preprint arXiv:2408.00118

    2024 arXiv

  10. [19]

    Bogdan Gliwa, Iwona Mochol, Maciej Biesek, and Aleksander Wawer. 2019. SAMSum corpus: A human-annotated dialogue dataset for abstractive summarization . In ACL

    2019

  11. [20]

    Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, and 1 others. 2024. The Llama 3 herd of models . arXiv preprint arXiv:2407.21783

    2024 arXiv

  12. [21]

    Tom Gunter, Zirui Wang, Chong Wang, Ruoming Pang, Andy Narayanan, Aonan Zhang, Bowen Zhang, Chen Chen, Chung-Cheng Chiu, David Qiu, and 1 others. 2024. Apple intelligence foundation language models. arXiv preprint arXiv:2407.21075

    2024

  13. [22]

    Masato Hagiwara and Masato Mita. 2020. G it H ub typo corpus: A large-scale multilingual dataset of misspellings and grammatical errors. In LREC

    2020

  14. [23]

    Hasan Hammoud, Umberto Michieli, Fabio Pizzati, Philip Torr, Adel Bibi, Bernard Ghanem, and Mete Ozay. 2024. Model merging and safety alignment: One bad model spoils the bunch. In EMNLP Findings

    2024

  15. [24]

    Zeyu Han, Chao Gao, Jinyang Liu, Jeff Zhang, and Sai Qian Zhang. 2024. Parameter-efficient fine-tuning for large models: A comprehensive survey. In TMLR

    2024

  16. [25]

    Edward J Hu, yelong shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. Lo RA : Low-rank adaptation of large language models. In ICLR

    2022

  17. [26]

    Chengsong Huang, Qian Liu, Bill Yuchen Lin, Tianyu Pang, Chao Du, and Min Lin. 2024. Lorahub: Efficient cross-task generalization via dynamic lora composition. In COLM

    2024

  18. [27]

    Gabriel Ilharco, Marco Tulio Ribeiro, Mitchell Wortsman, Suchin Gururangan, Ludwig Schmidt, Hannaneh Hajishirzi, and Ali Farhadi. 2023. Editing models with task arithmetic. In ICLR

    2023

  19. [28]

    Pegah Jandaghi, XiangHai Sheng, Xinyi Bai, Jay Pujara, and Hakim Sidahmed. 2024. Faithful persona-based conversational dataset generation with large language models. In NLP4ConvAI

    2024

  20. [29]

    Dawid J Kopiczko, Tijmen Blankevoort, and Yuki M Asano. 2024. VeRA: Vector-based random matrix adaptation . ICLR

    2024

  21. [30]

    Vladislav Lialin, Vijeta Deshpande, and Anna Rumshisky. 2023. Scaling down to scale up: A guide to parameter-efficient fine-tuning. arXiv preprint arXiv:2303.15647

    2023 arXiv

  22. [31]

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

    2024

  23. [32]

    Yixin Liu, Kejian Shi, Katherine S He, Longtian Ye, Alexander R Fabbri, Pengfei Liu, Dragomir Radev, and Arman Cohan. 2024 b . On learning to summarize with large language models as references. In NAACL

    2024

  24. [33]

    Agnes Luhtaru, Elizaveta Korotkova, and Mark Fishel. 2024. No error left behind: Multilingual grammatical error correction with pre-trained translation models. In EACL

    2024

  25. [34]

    Qi Lv, Ziqiang Cao, Lei Geng, Chunhui Ai, Xu Yan, and Guohong Fu. 2023. General and domain-adaptive chinese spelling check with error-consistent pretraining. ACM Transactions on Asian and Low-Resource Language Information Processing, 22(5):1--18

    2023

  26. [35]

    Grigory Malinovsky, Umberto Michieli, Hasan Abed Al Kader Hammoud, Taha Ceritli, Hayder Elesedy, Mete Ozay, and Peter Richt \'a rik. 2024. Randomized asymmetric chain of LoRA: The first meaningful theoretical framework for low-rank adaptation . arXiv preprint arXiv:2410.08305

    2024 arXiv

  27. [36]

    Qwen Team . 2024. https://qwenlm.github.io/blog/qwen2.5/ Qwen2.5: A party of foundation models

    2024

  28. [37]

    Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. 2016. SQ u AD : 100,000+ questions for machine comprehension of text. In EMNLP

    2016

  29. [38]

    Adithya Renduchintala, Tugrul Konuk, and Oleksii Kuchaiev. 2024. Tied- L o RA : Enhancing parameter efficiency of L o RA with weight tying. In NAACL

    2024

  30. [39]

    Donald Shenaj, Ondrej Bohdal, Mete Ozay, Pietro Zanuttigh, and Umberto Michieli. 2025. Lora.rar: Learning to merge loras via hypernetworks for subject-style conditioned image generation. In CVPR Workshop

    2025

  31. [40]

    Abigail Sticha, Norbert Braunschweiler, Rama Sanand Doddipatla, and Kate M Knill. 2024. Advancing faithfulness of large language models in goal-oriented dialogue question answering. In ACM Conference on Conversational User Interfaces

    2024

  32. [41]

    Chunlin Tian, Zhan Shi, Zhijiang Guo, Li Li, and Chengzhong Xu. 2024. HydraLoRA: An Asymmetric LoRA Architecture for Efficient Fine-Tuning . In NeurIPS

    2024

  33. [42]

    J \"o rg Tiedemann and Santhosh Thottingal. 2020. OPUS-MT — B uilding open translation services for the W orld. In EAMT

    2020

  34. [43]

    Kumar Utsav. 2023. RedPajama-INCITE-Base-3B-v1 model finetuned for Paraphrasing and Changing the Tone . https://huggingface.co/llm-toys

    2023

  35. [44]

    Mitchell Wortsman, Gabriel Ilharco, Samir Ya Gadre, Rebecca Roelofs, Raphael Gontijo-Lopes, Ari S Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Kornblith, and 1 others. 2022. Model soups: averaging weights of multiple fine-tuned models improves accuracy without in...

    2022

  36. [45]

    Shitao Xiao, Zheng Liu, Peitian Zhang, and Xingrun Xing. 2024. LM-Cocktail : Resilient tuning of language models via model merging. In ACL Findings

    2024

  37. [46]

    Lingling Xu, Haoran Xie, Si-Zhao Joe Qin, Xiaohui Tao, and Fu Lee Wang. 2023. Parameter-efficient fine-tuning methods for pretrained language models: A critical review and assessment. arXiv preprint arXiv:2312.12148

    2023 arXiv

  38. [47]

    Prateek Yadav, Derek Tam, Leshem Choshen, Colin A Raffel, and Mohit Bansal. 2024. TIES-merging: Resolving interference when merging models . In NeurIPS

    2024

  39. [48]

    An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, and 40 others. 2024. Qwen2 technical repo...

    2024 arXiv

  40. [49]

    Le Yu, Bowen Yu, Haiyang Yu, Fei Huang, and Yongbin Li. 2024. Language models are super mario: Absorbing abilities from homologous models as a free lunch. In ICML

    2024

  41. [50]

    Qingru Zhang, Minshuo Chen, Alexander Bukharin, Nikos Karampatziakis, Pengcheng He, Yu Cheng, Weizhu Chen, and Tuo Zhao. 2023. Adalora: Adaptive budget allocation for parameter-efficient fine-tuning. In ICLR

    2023

  42. [51]

    Yue Zhang, Zhenghua Li, Zuyi Bao, Jiacheng Li, Bo Zhang, Chen Li, Fei Huang, and Min Zhang. 2022. MuCGEC : a multi-reference multi-source evaluation dataset for chinese grammatical error correction. In NAACL

    2022

  43. [52]

    Jiacheng Zhu, Kristjan Greenewald, Kimia Nadjahi, Haitz S \'a ez de Oc \'a riz Borde, Rickard Br \"u el Gabrielsson, Leshem Choshen, Marzyeh Ghassemi, Mikhail Yurochkin, and Justin Solomon. 2024. Asymmetry in low-rank adapters of foundation models. In ICML

    2024

Pith tools

Reviewed August 15, 2026 · model on record in the stance chip above.