PortLLM: Personalizing Evolving Large Language Models with Training-Free and Portable Model Patches

## Abstract

Abstract As large language models (LLMs) increasingly shape the AI landscape, fine-tuning pretrained models has become more popular than in the pre-LLM era for achieving optimal performance in domain-specific tasks.
However, pretrained LLMs such as ChatGPT are periodically evolved ( i.e. , model parameters are frequently updated), making it challenging for downstream users with limited resources to keep up with fine-tuning the newest LLMs for their domain application. Even though fine-tuning costs have nowadays been reduced thanks to the innovations of parameter-efficient fine-tuning such as LoRA, not all downstream users have adequate computing for frequent personalization . Moreover, access to fine-tuning datasets, particularly in sensitive domains such as healthcare, could be time-restrictive, making it crucial to retain the knowledge encoded in earlier fine-tuned rounds for future adaptation. In this paper, we present PortLLM , a training-free framework that ( i ) creates an initial lightweight model update patch to capture domain-specific knowledge, and ( ii ) allows a subsequent seamless plugging for the continual personalization of evolved LLM at minimal cost. Our extensive experiments cover seven representative datasets, from easier question-answering tasks {BoolQ, SST2} to harder reasoning tasks {WinoGrande, GSM8K}, and models including { Mistral-7B , Llama2 , Llama3.1 , and Gemma2 }, validating the portability of our designed model patches and showcasing the effectiveness of our proposed framework.
For instance, PortLLM achieves comparable performance to LoRA fine-tuning with reductions of up to 12.2 × 12.2\times 12.2 × in GPU memory usage.
Finally, we provide theoretical justifications to understand the portability of our model update patches, which offers new insights into the theoretical dimension of LLMs’ personalization.

## 1 Introduction

The rise of large pretrained language models has marked a significant shift in natural language processing (NLP), enabling remarkable performance across a wide array of tasks, including natural language understanding and generation. These models, such as GPT-4 (Achiam et al., ), have achieved state-of-the-art performance by leveraging vast amounts of pretraining data and learning rich semantic representations that encode broad linguistic and world knowledge, which in turn allows them to generalize very well across domains (Antoniades et al., ). Despite their powerful general ability, pretrained LLMs often fall short in specialized domains where a nuanced understanding of technical language or context-specific knowledge is required (Wang et al., ; Bommasani et al., ; Qiu et al., ). Hence, while pretraining enables LLMs to capture general knowledge, fine-tuning (e.g., personalization) is essential for adapting these models to specific domains. Fine-tuning bridges this gap by adapting pretrained models to specific tasks, enhancing their performance in domains such as healthcare, legal analysis, or scientific research (Min et al., ; Wei et al., ; Ouyang et al., ; Wang et al., ; Liu et al., ; Raffel et al., ; Chen et al., ; Gao et al., ). For instance, fine-tuned models can more effectively recognize domain-specific terminology, reason about complex relationships, and deliver more accurate and contextual appropriate responses.

Much effort has been devoted to developing fine-tuning methods. Traditionally, fine-tuning would normally involve updating all the parameters of a model. For example, in the case of Mistral 7B (Jiang et al., ), it would involve updating all 7 billion parameters. Typically LLMs have billions of parameters, and so this process poses significant challenges in computational and memory requirements. To alleviate these constraints, many Parameter Efficient Fine-Tuning (PEFT) methods (Houlsby et al., ) have been proposed. One popular method is Low-Rank Adaptation (LoRA) (Hu et al., ), which aims to estimate an updated matrix $\Delta W$ using the product of two low-rank matrices $A$ and $B$. However, although LoRA lowers the training complexity, it still requires fine-tuning a large number of trainable parameters to reach a satisfactory performance. For example, LoRA fine-tuning Llama 2 13B (Touvron et al., ) variant would require up to eight A6000 GPUs with 48 GB VRAM each, for a very small batch size, hence imposing a considerable memory and computational burden.

Furthermore, as cloud-hosted LLMs like ChatGPT (OpenAI, ) and Gemini (Team et al., ) undergo periodic (bi-annually or shorter) updates with newer data, their improved performance often renders previous versions outdated. For downstream users who have already invested in fine-tuning these models for domain-specific tasks, repeatedly fine-tuning or performing personalization at every new update is highly impractical, as the process is not only computationally expensive but also time-consuming.

Beyond the computational and logistical hurdles, continual updates present another challenge for the downstream user: the lack of availability of the fine-tuning dataset. In domains such as healthcare or finance, data access is regulated by privacy laws and potentially time-sensitive. For example, fine-tuning medical models on patient data requires strict adherence to ethical and legal guidelines, making it difficult to repeatedly fine-tune with every model update. As a result, repeatedly fine-tuning models on newer LLM releases is not a viable long-term strategy for many users, hindering the downstream users from harnessing the performance gains from the evolving nature of LLMs. In response to these challenges, a nature research question comes:

To address this question, we introduce PortLLM, training-free framework that enables seamless transfer of domain-specific knowledge across evolving models. PortLLM leverages model patches derived from LoRA, allowing users to port fine-tuned knowledge from one model iteration to another while preserving or even enhancing the performance of a downstream task. We show that our model patches are portable across model updates. If the downstream user fine-tunes a version of the model that has long become obsolete, they can simply add the model patches to the newer model, maintaining or boosting their performance on the downstream task. PortLLM eliminates the need for costly periodic fine-tuning, offering a scalable solution for maintaining task-specific performance across different model versions.
Our contributions can be summarized as follows:

- ❶
We introduce PortLLM, a training-free framework designed to transfer knowledge between different versions of an evolving LLM. Given two model versions, PortLLM leverages task-specific model patches extracted from a pretrained LLM and seamlessly applies them to the updated version of the pretrained LLM. This process allows the updated model to achieve comparable, and in some cases improved, performance on downstream tasks — without any need for fine-tuning.
- ❷
Why do our model patches work? We address this question through both theoretical analysis and empirical investigation. Our findings reveal that certain terms in the model patch are effectively negligible, enabling us to create a simplified version of the patch that requires no training. Consequently, adding the simplified model patches alone is sufficient to achieve improved performance on the downstream task. Furthermore, we examine the impact of the pretraining dataset on downstream tasks, demonstrating that our framework can harness the benefits of continued pretraining across different model updates, across different pretraining datasets including {OpenOrca, SlimOrca, OpenPlatypus, AlpacaGPT4}.
- ❸
We conduct extensive experiments across a series of seven downstream tasks, including Question-Answering Tasks {BoolQ, SST-2} (Wang, ; Wang et al., ), Similarity and Paraphrase Tasks {MRPC} (Wang, ), Inference Tasks {RTE, WNLI} (Wang, ), and Reasoning Tasks {WinoGrande, GSM8K} (Sakaguchi et al., ; Cobbe et al., ). To further demonstrate the robustness and broad applicability of our approach, we evaluate it on multiple model architectures, such as Mistral-7B, Llama2-7B, Llama3.1-8B, and Gemma2-9B. Additionally, we explore the applicability of our method on full-weight continued pretraining compared to LoRA-based continued pretraining and show the effectiveness of our method by quantifying the gains on GPU memory usage (of up to $12.2\times$ reduction), GPU hours, and decrease in the number of trainable parameters (to zero trainable parameters).

## 2 Related Works

#### Large Language Models (LLMs).

LLMs have transformed natural language processing, enabling models to perform complex tasks with remarkable accuracy and generalization. Models like GPT-3 (Brown et al., ), BERT (Devlin et al., ), and T5 (Raffel et al., ) have set benchmarks across a range of NLP tasks, from translation and summarization to question answering and text generation (Vaswani et al., ; Zhang et al., ; Rajpurkar et al., ). More recently, models like Llama (Touvron et al., ; Dubey et al., ), Mistral (Jiang et al., ), and Gemma (Team et al., ) have pushed the boundaries further by optimizing both performance and computational efficiency. Llama was particularly notable for achieving state-of-the-art results with smaller model size, emphasizing that scaling down can still maintain performance. Mistral improves upon this by offering more efficient training methods, allowing faster training times without sacrificing model quality. Similarly, Gemma leverages architectural innovations to enhance model training and inference, focusing on reducing resource requirements while maintaining strong performance. Despite these advances, the computational demands for pretraining LLMs remain extremely high. Training large models requires weeks of computation on high-performance hardware, and continuous pretraining—to keep models updated with the latest data—adds further complexity and cost (Brown et al., ). Even after pretraining, the process of fine-tuning these models for specific downstream tasks remains resource-intensive, making the deployment of LLMs at scale a significant challenge (Raffel et al., ). This cost barrier continues to limit the accessibility and widespread adoption of LLMs across diverse applications. In this paper, we propose a training-free solution that enables the seamless transfer of personalized knowledge across evolving LLMs, reducing the need for costly fine-tuning and enhancing accessibility.

#### Parameter Efficient Fine-tuning (PEFT).

The rapid growth in the size of pretrained LLMs has posed significant challenges for efficiently fine-tuning LLMs to specific downstream tasks. To address this, numerous PEFT methods have been developed, aiming to balance efficiency and accuracy. Early approaches focused on inserting trainable adapters—feed-forward networks placed between the layers of the pretrained model (Houlsby et al., ; Lin et al., ).
Recent advancements have led to more sophisticated adapter-based PEFT methods (Mahabadi et al., ; Pfeiffer et al., ; Luo et al., ). A notable example is LoRA (Hu et al., ), which introduces trainable low-rank weight perturbations to the pretrained model, significantly reducing the number of parameters required for fine-tuning. LoRA’s key innovation lies in its use of the product of two low-rank matrices to approximate weight changes. Building upon this concept, Q-LoRA (Dettmers et al., ) proposes to propagate gradients through LoRA using a $4$-bit quantized pretrained model, further enhancing efficiency.
Concurrently, prompt-based learning methods have demonstrated effectiveness across various NLP tasks. Methods such as prompt-tuning (Lester et al., ) and prefix-tuning (Li & Liang, ) incorporate learnable continuous embeddings into the model’s hidden states. They condition the frozen model to adapt to specific tasks without modifying the underlying architecture. Despite these advances, fine-tuning each updated LLM with PEFT to equip personalized knowledge remains highly costly, and how PEFT can bridge the gap in personalized settings within this evolving environment in a portable manner is yet to be fully explored. To this end, we develop in this paper the theory behind portable model patches that can be plugged into an updated model to carry over the personalized knowledge from the first fine-tuned model.

## 3 Methodology

### 3.1 Preliminaries

Figure: Figure 1: The diagram illustrates the core components of PortLLM, a training-free framework to port personalized knowledge between evolving LLMs. Initially, a pretrained LLM is fine-tuned using LoRA. We transfer this task-specifc knowledge without requiring the newer updated model to be fine-tuned again. This allows for continual performance improvements on downstream tasks without additional periodic fine-tuning.
Refer to caption: extracted/5952410/figs/teaserv2.png

#### Transformers.

Transformer models (Vaswani et al., ) is an architecture that has revolutionized NLP and other sequence-based tasks. It consists of two key components: (1) Multi-Head Self-Attention and (2) Feed-Forward Neural Network. The Multi-Head Self-Attention mechanism is the core innovation of transformers. It computes the weighted representation of the input sequence where each token attends to every other token. Suppose we are given an input $X\in\mathbb{R}^{n\times d}$ where $n$ refers to the sequence length and $d$ is the hidden dimension of the transformer model. Then for any given attention head $i$ with a total of $H$ heads, we define the following three matrices: query matrix $W_{q_{i}}\in\mathbb{R}^{d\times d_{H}}$, key matrix $W_{k_{i}}\in\mathbb{R}^{d\times d_{H}}$ and value matrix $W_{v_{i}}\in\mathbb{R}^{d\times d_{H}}$, where $d_{H}=d/H$. Given these, we can compute the self-attention for the $i$th head as follows

$$ $h_{i}=\operatorname{Softmax}\left(\frac{XW_{q_{i}}(XW_{k_{i}})^{T}}{\sqrt{d_{H }}}XW_{v_{i}}\right),\quad i=1,\dots,H.$ (1) $$

The outputs of the $H$ attention heads are then concatenated as follows:

$$ $\text{Multi-head Self-Attention}(X)=\operatorname{Concatenate}(h_{1},h_{2}, \dots,h_{H})W_{o}\,,$ (2) $$

where $W_{o}\in\mathbb{R}^{d\times d}$ is a projection matrix that combines the outputs of the different heads back into the model’s hidden dimension $d$. After the Muli-head Self-Attention, the output is passed through a position-wise feed-forward network that consists of two linear transformations and a nonlinear activation function (like ReLU or GELU). Given the weight matrix of the first linear layer $W_{\text{up}}\in\mathbb{R}^{d\times d_{m}}$, the weight matrix of the second layer $W_{\text{down}}\in\mathbb{R}^{d_{m}\times d}$, bias terms $b_{1}\in\mathbb{R}^{d_{m}}$, $b_{2}\in\mathbb{R}^{d}$, and a non-linear activation function $\sigma(\cdot)$ where $d_{m}$ is the hidden dimension, Feed-Forward Network is applied independently to each position in the sequence as follows

$$ $\text{Feed-Forward Network}(X)=\sigma(XW_{\text{up}}+b_{1})W_{\text{down}}+b_{ 2}\,.$ (3) $$

Furthermore, these two layers are wrapped with residual connections and layer normalization.

#### Low-Rank Adaptation (LoRA).

Consider a transformer model where $W_{0}\in\mathbb{R}^{d\times d}$ is the pretrained weight matrix, which could be a weight matrix for any layer in the transformer. In a typical fine-tuning setup, the weights $W_{0}$ are updated during training to adapt the model to a specific task. This update requires storing and computing the entire matrix $W_{0}$ during training, which becomes computationally expensive for large models. Instead of updating the full weight matrix $W_{0}$, LoRA (Hu et al., ) assumes that the weight update $\Delta W\in\mathbb{R}^{d\times d}$, essentially the difference between pretrained weights $W_{0}$ and the hypothetical fine-tuned weight, can be approximated by a low-rank decomposition:

$$ $\Delta W=BA,$ (4) $$

where $B\in\mathbb{R}^{d\times r}$ and $A\in\mathbb{R}^{r\times d}$ are trainable matrices, while $r$ is the rank of the decomposition with $r\ll d$. In this setup, the full weight update matrix $\Delta W$ is replaced by the product of two smaller matrices, $B$ and $A$, drastically reducing the number of trainable parameters from $d^{2}$ to $2rd$. Hence, the fine-tuned model weights we can be trained as follows:

$$ $W_{\text{new}}=W_{0}+\Delta W=W_{0}+BA.$ (5) $$

By doing this, LoRA reduces the number of parameters that need to be trained while still allowing the model to adapt to new tasks.

### 3.2 Proposed Training-Free Framework: PortLLM

#### Notations and Assumptions.

We refer to the pretrained LLM as the first version of the model, denoted by $\theta$, and the updated continued pretrained model as $\theta^{\prime}$, as illustrated in Figure 2. We also assume that to get to $\theta^{\prime}$, the provider does continued pretraining using LoRA, where $\Delta\theta$ denotes this adapter, however empirical experiments in Section 4.4 show that even if the provider does full weight continued pretraining on the newer dataset, our method still holds. We denote this full weight updated model as $\phi$. Similarly, for any downstream user $i$, we have a corresponding dataset denoted $d_{i}$. The base model fine-tuned on this dataset $d_{i}$ is denoted by $\theta_{i}$. We can also rewrite $\theta_{i}$ in terms of its LoRA update as $\theta_{i}=\theta+\Delta\theta_{i}$. Consequently, if we fine-tune updated model $\theta^{\prime}$ for $i$th downstream task, we have $\theta^{\prime}_{i}=\theta^{\prime}+\Delta\theta^{\prime}_{i}$.
We further assume that a personalization adaptor $\Delta\theta_{i}$ or $\Delta\theta^{\prime}_{i}$ has a rank that is much smaller than that of a continued pretrained adaptor $\Delta\theta$ or $\Delta\theta^{\prime}$.

Figure: Figure 2: LLM’s evolution & personalization cycle.
Refer to caption: extracted/5952410/figs/Theoryv2.png

#### Proposed Method of PortLLM .

PortLLM aims to approximate the fine-tuned updated model $\theta^{\prime}_{i}$ by applying the older personalization adaptor/model patch $\Delta\theta_{i}$ to the continued pretrained model $\theta^{\prime}$.
It will be shown in Section 3.3 that the older model patch $\Delta\theta_{i}$ may be used in lieu of the newer model patch $\Delta\theta_{i}^{\prime}$, namely,

$$ $\theta_{i}^{\prime}=\theta^{\prime}+\Delta\theta_{i}^{\prime}\approx\theta^{ \prime}+\Delta\theta_{i}.$ (6) $$

In other words, one can readily add the extra knowledge $\Delta\theta_{i}$ from the previous fine-tuning process to the newest LLM $\theta^{\prime}$. Throughout our experimental section, we perform experiments with this approximated patching process.

### 3.3 Analysis of Our Proposed Portability

#### Theoretical Justification.

The fine-tuned updated model $\theta^{\prime}_{i}$ can be decomposed into a naive update term and a residual matrix $C$ as follows:

$$ $\displaystyle\theta_{i}^{\prime}$ $\displaystyle=\theta^{\prime}+\Delta\theta_{i}^{\prime}$ (7a) $\displaystyle=\underbrace{(\theta^{\prime}+\Delta\theta_{i})}_{\text{Naive Update}}+\underbrace{(\Delta\theta_{i}^{\prime}-\Delta\theta_{i})}_{\text{ Residual Matrix }C}.$ (7b) $$

Lemma: We claim that the residual matrix is negligible compared to the naive update. Proof:
First, recall the assumption in Section 3.2 that $\Delta\theta_{i}^{\prime}$ and $\Delta\theta_{i}$ have ranks that are much smaller than the rank of $\Delta\theta$. Second, $\theta^{\prime}=\theta+\Delta\theta$ ensures that $\operatorname{rank}(\theta^{\prime})\geq\operatorname{rank}(\theta)$. We therefore conclude that the rank of the residual matrix is approximately much smaller than that of the naive update matrix.

**Table 1: Comparison of the terms making up our framework across different datasets.**
| Term |  | BoolQ | MRPC | RTE | WNLI |
| --- | --- | --- | --- | --- | --- |
| $\theta^{\prime}+\Delta\theta_{i}$ | $\sigma_{\max}$ | $7.37$ | $7.37$ | $7.37$ | $7.37$ |
|  | $\|\cdot\|_{F}$ | $16.80$ | $16.80$ | $16.81$ | $16.81$ |
| $\Delta\theta_{i}^{\prime}-\Delta\theta_{i}$ | $\sigma_{\max}$ | $0.19$ | $0.14$ | $0.10$ | $0.08$ |
|  | $\|\cdot\|_{F}$ | $0.21$ | $0.13$ | $0.12$ | $0.09$ |
| $\nicefrac{{\sigma_{\max}}}{{\sigma_{\max}}}$ |  | $38.77$ | $51.37$ | 76.32 | $96.24$ |
| $\nicefrac{{\|\cdot\|_{F}}}{{\|\cdot\|_{F}}}$ |  | $79.04$ | $126.70$ | $145.43$ | $194.30$ |

#### Empirical Validation.

We empirically show that the difference between two personalization updates, $C=\Delta\theta_{i}^{\prime}-\Delta\theta_{i}$, is negligible when compared to naive update term, $\theta^{\prime}+\Delta\theta_{i}$.
We use Frobenius norm, $\|\cdot\|_{F}$, and the maximum singular value, $\sigma_{\max}$, to measure the magnitudes of matrices. The results are summarized in Table 1 across four different downstream tasks {BoolQ, MRPC, RTE, WNLI}. We can see that the $\sigma_{\max}$ for first term are on average $66\times$ and the $\|\cdot\|_{F}$ is $136\times$ bigger in the favor of the first term, which implies that $C$ is comparatively negligible, hence our model patch can be simplified as shown in (6).

## 4 Experiments

#### Datasets and Architecture.

We evaluate our framework on a diverse set of datasets to demonstrate PortLLM universality and effectiveness across various downstream tasks and domains. Specifically, we leverage datasets from the GLUE (Wang, ), SuperGLUE (Wang et al., ), WinoGrande (Sakaguchi et al., ) and GSM8K (Cobbe et al., ) benchmarks commonly used for such evaluation in literature. For Question Answering tasks, we utilize BoolQ (from SuperGLUE) and SST-2 (from GLUE); for Similarity and Paraphrase Tasks, the MRPC (from GLUE) dataset; for Inference Tasks, the RTE and WNLI (both from GLUE) datasets; and lastly for Reasoning Tasks, we employ WinoGrande and GSM8K. This broad spectrum of tasks enables a comprehensive evaluation of our model’s performance across diverse downstream applications. For continued pretraining datasets, we use the following: OpenOrca (Lian et al., ), SlimOrca (Lian et al., ), OpenPlatypus (Lee et al., ) and AlpacaGPT4 (Peng et al., ). Additionally, we conduct extensive experiments across multiple model architectures to demonstrate the generalizablity of our framework. Specifically, we test our method on Mistral-7B (Jiang et al., ), Llama2-7B (Touvron et al., ), Llama3.1-8B (Dubey et al., ), and Gemma2-9B (Team et al., ), showcasing the robustness and adaptability of our approach across different LLMs.

#### Training Details.

To simulate the progression of time, we employ continued pretraining, where we transition from $\theta$ to $\theta^{\prime}$ by taking a pretrained model and further pretraining it on a specific dataset using LoRA (Hu et al., ). In all continued pretraining scenarios, we maintain a constant rank $r=64$ and $\alpha=128$ with a learning rate of $0.0001$ and $4$ epochs. For downstream tasks, we also use LoRA, but in this case, we set the rank $r=8$ consistently to ensure a fair comparison across tasks. Furthermore, for all LoRA applications we optimize all the attention layers (Key, Value, Query, Projection), and all Feed Forward Network layers (Up Projection, Down Projection and Gate Projection, where applicable). For each downstream fine-tuning, we use a constant learning rate of $0.0004$ while the number of epochs for each dataset {BoolQ, SST-2, MRPC, RTE, WinoGrande, WNLI, GSM8K} is as follows {$5,5,5,5,3,5,1$}. Lastly, for fine-tuning on specific downstream dataset mentioned, we solely use the train split, and evaluate on test split.

#### Evaluation Metrics.

We use the Language Model Evaluation Harness (Gao et al., ) by EleutherAI to assess the performance of all trained and fine-tuned models across the datasets in our experiments. All evaluations are conducted in a zero-shot setting rather than a few-shot setting. For datasets {BoolQ, SST-2, RTE, WinoGrande, WNLI}, we employ accuracy as the primary evaluation metric. In the case of {MRPC}, we utilize both accuracy and F1 score to provide a more comprehensive evaluation. For {GSM8K}, we had two evaluation options: (1) Flexible Match Accuracy or (2) Exact Match Accuracy. Due to poor zero-shot performance of the models on GSM8K for exact matches, we opted for Flexible Match Accuracy.

**Table 2: Zero-shot performance comparison of model patches and baselines models on Mistral-7B, using the OpenOrca dataset for continued pretraining.**
| Model Version | BoolQ | SST-2 | MRPC | RTE | WinoGrande | WNLI | GSM8K |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | Accuracy | Accuracy | Accuracy/F1 | Accuracy | Accuracy | Accuracy | Accuracy |
| Pretrained LLM $\theta$ | $83.58$ | $66.86$ | $65.20$ / $73.70$ | $67.51$ | $74.11$ | $57.76$ | $6.37$ |
| Updated LLM $\theta^{\prime}$ | $87.46$ | $82.91$ | $74.75$ / $83.73$ | $75.09$ | $75.06$ | $57.72$ | $15.16$ |
| Fine-tuned LLM $\theta_{i}$ | $91.01$ | $95.99$ | $89.46$ / $92.62$ | $87.73$ | $85.95$ | $83.11$ | $34.04$ |
| Fine-tuned Updated LLM $\theta^{\prime}_{i}$ | $90.67$ | $96.22$ | $89.20$ / $93.03$ | $89.89$ | $86.05$ | $82.08$ | $34.95$ |
| $\theta^{\prime}+\Delta\theta_{i}$ (Ours) | $90.24$ | $96.10$ | $88.73$ / $92.10$ | $89.17$ | $85.01$ | $83.10$ | $41.32$ |

### 4.1 Superiority of PortLLM Framework

In this section, we compare the performance of our model patches against several baseline models, including the pretrained LLM $\theta$, the updated model using continued pretraining $\theta^{\prime}$, the fine-tuned model $\theta_{i}$, and the updated fine-tuned model $\theta^{\prime}_{i}$. For consistency, all models are variations of Mistral-7B, while continued pretraining dataset is OpenOrca. Importantly, the performance is evaluated under zero-shot setting across all the datasets. The results are summarized in Table 2.

❶ Compared to the zero-shot accuracy of updated model $\theta^{\prime}$, applying our model patches can result in a significant performance gains, with improvements up to $2.7\times$. Notably, no additional training is required when applying these patches, as the process simply involves a merge operation. Across all evaluated datasets {BooLQ, SST-2, MRCP, RTE, WinoGrande, WNLI, GSM8K}, we observe substantial zero-shot performance gains of $\{2.7\%,13.19\%,13.98\%,14.08\%,9.95\%,25.38\%,26.16\%\}$, respectively. This implies that our model patches are capable of transferring personalized knowledge across the different model versions.

❷ Comparing the performance of our model patches applied to the updated model $\theta^{\prime}+\Delta\theta_{i}$ with that of the fine-tuned model $\theta^{\prime}$, we observe that our method successfully transfers most of the downstream task-specific knowledge, yielding comparable results. As shown in Table 2, for tasks {BoolQ, MRPC, WinoGrande, WNLI}, the performance is nearly identical, with a maximum difference of only $0.77\%$ in favor of the fine-tuned model. However, in tasks like {SST-2, RTE, GSM8K}, our approach outperforms the fine-tuned model by {$0.11\%,1.44\%,7.28\%$}, respectively. These results suggest that, when paired with a pretraining dataset that enhances performance for a specific task, our model patches can further leverage this advantage to improve downstream task performance in certain cases.

❸ Moreoever, our method performs on par with the fine-tuned updated model ($\theta^{\prime}+\Delta\theta_{i}$ compared to $\theta_{i}^{\prime}$), as evident from the comparison of the last two rows in Table 2. The difference between the two approaches are minimal when it comes to performance, with a maximum variation of just $1.04\%$ observed in the case of WinoGrande. Notably, while one method requires fine-tuning, our approach remains completely training-free. Additionally, for certain downstream tasks such as WNLI and GSM8K, our method outperforms the fine-tuned updated model by $1.02\%$ and $6.37\%$, respectively. This demonstrates that our approach not only provides comparable results but can, in some instances, surpass the performance of a fine-tuned evolved model.

### 4.2 Consistent Results across Different Pretraining Datasets

In this section, we investigate the impact of different pretraining datasets on our model patches $\Delta\theta_{i}$ and assess whether our method can effectively leverage updates obtained through continued pretraining. We conduct a comparative analysis across four downstream datasets – {BoolQ, MRPC, WNLI, WinoGrande} – alongside four distinct continued pretraining datasets: OpenOrca, SlimOrca, OpenPLatypus, and AlpacaGPT4. Consistent with our previous section, all experiments utilize the Mistral-7B model. The results of this analysis are summarized in Table 3.

❶ The results presented in Table 3 demonstrate that our model patches exhibit strong portability across different downstream tasks, irrespective of the continued pretraining dataset used. For each specific downstream task, we observe substantial improvements in zero-shot performance compared to the updated model $\theta^{\prime}$ across all pretraining datasets. For instance, in the case of WNLI, the performance boosts are $\{25.38\%,18.30\%,26.76\%,28.17\%\}$ for {OpenOrca, SlimOrca, OpenPlatypus, AlpacaGPT4} datasets, respectively. A similar trend of significant improvement is also evident across other downstream tasks.

**Table 3: Performance comparison of model patches $\Delta\theta_{i}$ across four downstream tasks {BoolQ, MRPC, WNLI, WinoGrande} using different continued pretraining datasets {OpenOrca, SlimOrca, OpenPlatypus, AlpacaGPT4}. All models are based on Mistral-7B.**
| Dataset | Model | BoolQ | MRPC | WNLI | WinoGrande |
| --- | --- | --- | --- | --- | --- |
|  |  | Accuracy | Accuracy | Accuracy | Accuracy |
| OpenOrca | Updated Model $\theta^{\prime}$ | $87.46$ | $74.75$ | $57.72$ | $75.06$ |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $90.24$ $(\uparrow 2.78)$ | $88.73$ $(\uparrow 13.98$) | $83.10$ $(\uparrow 25.38)$ | $85.01$ $(\uparrow 9.95)$ |
| SlimOrca | Updated Model $\theta^{\prime}$ | $87.16$ | $74.76$ | $64.79$ | $74.98$ |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $90.07$ $(\uparrow 2.91)$ | $87.75$ $(\uparrow 12.99)$ | $83.09$ $(\uparrow 18.30)$ | $85.59$ $(\uparrow 10.61)$ |
| OpenPlatypus | Updated Model $\theta^{\prime}$ | $83.73$ | $70.10$ | $53.52$ | $73.95$ |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $90.34$ $(\uparrow 6.61)$ | $90.20$ $(\uparrow 20.10)$ | $80.28$ $(\uparrow 26.76)$ | $83.58$ $(\uparrow 9.63)$ |
| AlpacaGPT4 | Updated Model $\theta^{\prime}$ | $83.94$ | $71.32$ | $56.34$ | $74.82$ |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $90.52$ $(\uparrow 6.58)$ | $89.22$ $(\uparrow 17.90)$ | $84.51$ $(\uparrow 28.17)$ | $84.93$ $(\uparrow 10.11)$ |

❷ We further observe from Table 3 that certain pretraining datasets can either enhance or detract from the zero-shot performance of $\theta^{\prime}$ on specific downstream tasks, and this effect carries over to our frameworks to some degree. For instance, continued pretraining on OpenPlatypus leads to a decrease in performance on the WNLI dataset. Consequently, the addition of our model patch in this scenario results in the lowest accuracy for this particular downstream task among all the pretraining datasets evaluated.

### 4.3 Consistent Results across Different Model Architectures

This section provides a comprehensive analysis of our model patches across various architectures to evaluate their performance. We examine four different model architectures: {Mistral-7B, Llama2-7B, Llama3.1-8B, Gemma2-9B}, assessing their effectiveness on four distinct downstream tasks {BoolQ, MPRC, WNLI, WinoGrande}. Performance is evaluated under four settings : (1) pretrained model, (2) continued pretrained model or Updated Model, (3) fine-tuned model, and (4) our model patches ported to the updated model. The OpenOrca dataset is used for our continued pretraining in this analysis. The results are summarized in Table 4

❶ The results across different model architectures indicate that our training-free model patches significantly enhance zero-shot performance for all downstream tasks. In each case, our approach matches personalized performance (fine-tuned model), and in certain instances, it even surpasses it. For example, with Gemma2-9B, when the personalized performance exceeds our method, the difference in accuracy is at most $0.73\%$, which can considered negligible. Conversely, in scenarios where our method outperforms personalized performance, we observe improvements of up to $5.53\%$. A similar trend is noted across the other model architectures, as detailed in Table 4.

❷ Additionally, we observe that fine-tuning is essential for achieving optimal zero-shot performance on downstream tasks. Across all model architectures, the zero-shot performance of both the pretrained model $\theta$ and the updated model $\theta^{\prime}$ is subpar, with particularly poor results noted on tasks like WNLI. This reinforces the notion that excellent performance necessitates some form of fine-tuning, further motivating the need for our training-free framework. Another significant finding is the slight performance improvement for downstream tasks across all model architectures due to continued pretraining. Therefore, it is advisable for the downstream user to utilize the updated model weights, as this may provide beneficial enhancements in performance.

**Table 4: Performance analysis of model patches across various architectures {Mistral-7B, Llama2-7B, Llama3.1-8B, Gemma2-9B} on four downstream tasks {BoolQ, MRPC, WNLI, WinoGrande} under four different model settings. For each downstream task bold highlights the best performance for each model architecture.**
| Model | Version | BoolQ | MRPC | WNLI | WinoGrande |
| --- | --- | --- | --- | --- | --- |
|  |  | Accuracy | Accuracy/F1 | Accuracy | Accuracy |
| Mistral 7B | Pretrained Model $\theta$ | $83.58$ | $65.20$ / $73.70$ | $57.76$ | $74.11$ |
|  | Updated Model $\theta^{\prime}$ | $87.46$ | $74.75$ / $83.73$ | $57.72$ | $75.06$ |
|  | Fine-tuned Model $\theta_{i}$ | 91.01 | 89.46 / 92.62 | 83.11 | 85.95 |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $90.24$ | $88.73$ / $92.10$ | $83.10$ | $85.01$ |
| Llama 2 7B | Pretrained Model $\theta$ | $77.74$ | $69.12$ / $81.52$ | $45.07$ | $69.06$ |
|  | Updated Model $\theta^{\prime}$ | $82.69$ | $69.61$ / $81.60$ | $47.89$ | $70.48$ |
|  | Fine-tuned Model $\theta_{i}$ | $88.21$ | $88.97$ / $92.01$ | 57.75 | $75.45$ |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | 88.32 | 89.95 / 92.56 | $53.77$ | 76.87 |
| Llama 3.1 8B | Pretrained Model $\theta$ | $82.35$ | $66.91$ / $77.54$ | $59.15$ | $73.56$ |
|  | Updated Model $\theta^{\prime}$ | $85.63$ | $75.00$ / $83.60$ | $61.95$ | $73.64$ |
|  | Fine-tuned Model $\theta_{i}$ | 90.22 | $84.31$ / $89.51$ | 83.10 | 85.71 |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $90.03$ | 89.71 / 92.71 | $81.69$ | $84.85$ |
| Gemma 2 9B | Pretrained Model $\theta$ | $83.98$ | $68.63$ / $74.19$ | $57.75$ | $74.19$ |
|  | Updated Model $\theta^{\prime}$ | $88.41$ | $77.21$ / $84.93$ | $74.65$ | $76.72$ |
|  | Fine-tuned Model $\theta_{i}$ | 91.38 | 91.42$/$93.83 | $83.20$ | 83.98 |
|  | Ours $\theta^{\prime}+\Delta\theta_{i}$ | $91.16$ | $90.69$ / $93.17$ | 88.73 | $83.82$ |

### 4.4 PortLLM Also Works with Full Weight Continued Pretraining

For our theoretical analysis, we initially assumed that continued pretraining was conducted using LoRA. However, we aim to investigate whether our method is effective across model evolution when the updates occur through full weight continued pretraining. Such a model is denoted $\phi$. To evaluate this, we utilize Mistral-7B, which has undergone full weight continued pretraining on the OpenOrca dataset, and incorporate our model patches for various downstream tasks. We then compare the performance of these patched models against the zero-shot performance of $\phi$ to assess the improvements attributable to our model patches. The results across various downstream tasks are summarized in Table 5.

**Table 5: Evaluation of model patches added to Mistral-7B with full weight continued pretraining on the OpenOrca dataset across various downstream tasks.**
| Model Version | BoolQ | SST-2 | MRPC | RTE | WinoGrande | WNLI | GSM8K |
| --- | --- | --- | --- | --- | --- | --- | --- |
|  | Accuracy | Accuracy | Accuracy/F1 | Accuracy | Accuracy | Accuracy | Accuracy |
| Full Weight Updated Model $\phi$ | $86.61$ | $93.81$ | $77.21$ / $85.31$ | $75.09$ | $72.77$ | $63.38$ | $20.55$ |
| $\phi+\Delta\theta_{i}$ (Ours) | $89.88$ | $95.53$ | $87.25$ / $90.97$ | $90.61$ | $85.08$ | $80.28$ | $41.24$ |

We find that our model patches can be effectively applied to a continued pretrained model utilizing full weight updates, rather than relying solely on LoRA. Across all evaluated datasets – {BoolQ, SST-2, MRPC, RTE, WinoGrande, WNLI, GSM8K} – we observe significant performance improvements of $\{3.27\%,1.72\%,10.04\%,15.52\%,12.31\%,16.90\%,20.69\%\}$, respectively, compared to the zero-shot performance of the Updated Model.

**Table 6: Efficiency Comparison Between PortLLM and LoRA on SST-2 with Mistral-7B as the model architecture. The table compares trainable parameters, GPU Memory Usage, and GPU Hours for PortLLM, and LoRA fine-tuning.**
| Metric | Ours $\theta^{\prime}+\Delta\theta_{i}$ | Fine-tuning Model $\theta_{i}$ | Savings |
| --- | --- | --- | --- |
| # Trainable Parameters | 0 0 | $20,971,520$ | $100\%$ |
| GPU Memory Utilization (GB) | $28.71$ | $350.61$ | $12.21\times$ |
| GPU Hours | $0.0083$ | $40.65$ | $4897\times$ |

### 4.5 Computing Efficiency Comparison of PortLLM

This section evaluates the performance of our method from an efficiency perspective. We employ the following metrics for comparison: (1) Number of Trainable Parameters, (2) GPU Memory Utilization, and (3) GPU Hours. We analyze the merging of our model patches in relation to model fine-tuning using LoRA to achieve comparable performance. For LoRA fine-tuning calculations, we have the following settings: Downstream task SST-2 for Mistral-7B, with local Batch Size of $4$ and $5$ Epochs. The results are summarized in Table 6.

Compared to downstream fine-tuning using LoRA, our methods offers plug-and-play solution with no trainable parameters, resulting in a reduction of nearly $20$ million parameters that need to be trained. This training-free paradigm not only conserves resources but also saves up to $12.2\times$ GPU Memory, reducing the requirement from $350$ GB for LoRA to just $28.7$ GB during the merge operation of model patches. Additionally, the merge operation can be executed in mere seconds, in start contrast to the hours required for fine-tuning. This opens many other doors for applications of our model patches. PortLLM demonstrates the potential for on-device, training-free models for various down-stream tasks without the need for fine-tuning. Furthermore, it reduces the need for expensive cloud infrastructure, especially in large-scale fine-tuning.

## 5 Conclusion

In this paper, we propose PortLLM, a framework aimed at addressing the challenges faced by downstream users of pretrained LLMs when adapting to frequent model evolutions over time. By leveraging lightweight model patches, PortLLM offers a training-free, cost-effective solution to seamlessly transfer domain-specific knowledge between different iterations of LLMs. This enables users to maintain, and sometimes even enhance, their models’ performance on specialized tasks without the need for repeated fine-tuning or extensive computational resources. Through extensive empirical evaluations across a set of tasks and models, we demonstrate that our method not only preserves performance but can also leverage the continual updates in pretraining LLMs, offering substantial gains in-task specific performance. Moreover, we provide theoretical insights into the portability of these model patches, highlighting the underlying factors that make them effective across evolving model versions. Looking forward, PortLLM paves the way for more robust and adaptable solutions in the evolving landscape of LLM personalization, offering another avenue for training-free adaptation. Furthermore, future endeavours will aim at developing such methods that work across different model architecture, including using techniques from model merging.

## Peer Reviews

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: - Theoretically, the proposed method $\theta’ + \Delta \theta_i$ introduces error compared to $\theta’ + \Delta \theta_i’$, potentially leading to worse performance. However, in Table 2, a large proportion of $\theta’ + \Delta \theta_i$ results outperform $\theta’ + \Delta \theta_i’$ (the fine-tuned updated LLM). Could the authors elaborate on potential reasons contributing to this improvement?

- What does “# Trainable Parameters” signify in Table 6? Why does the fine-tuning model have zero trainable parameters, while the proposed training-free approach has a large number of trainable parameters?

- In line with the discussion in Weaknesses, could the authors investigate the impact of the approximation error introduced by the proposed method? For instance, providing metrics similar to those in Table 1 for all datasets, along with the corresponding performance gains, could offer a clearer understanding of how this factor contributes to overall performance.
soundness: 3
strengths: The proposed method is based on the observation that residual parameter updates are negligible compared to the naive update, which is both intriguing and empirically proven effective.
summary: This paper proposes a training-free personalization approach for evolving LLMs. Specifically, the proposed PortLLM utilizes LoRA parameters from finetuning older models to approximate updated models. Extensive experiments validate the effectiveness of the proposed approach.
weaknesses: The paper’s core claim is that the residual matrix $\Delta \theta_i’ - \Delta \theta_i$ is negligible in value compared to the naive update $\theta’ + \Delta \theta_i$. Although the authors provide both theoretical and empirical justifications for this, the Lemma (lines 266-269) only establishes that $\text{rank}(\Delta \theta_i’ - \Delta \theta_i) \ll \text{rank}(\theta’ + \Delta \theta_i)$, which does not directly imply that the former is negligible in value relative to the latter. While this statement is supported by empirical results in Table 1, a theoretical proof or an estimated error bound would strengthen the justification, as this could represent a significant proportion of the error for this method.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 3
questions: 1.	In Table 2, why does your method show such a large improvement on the WNLI task compared to the Fine-tuned LLM and Fine-tuned Updated LLM?

2.	Line 344: There is a notation error for the fine-tuned model, it should be $\theta_i$.

3.	Are the two columns of values in Table 6 reversed?
soundness: 3
strengths: 1. The framework proposes a training-free alternative to recurrent fine-tuning, which could be useful for applications with limited resources.
2. The portability across model versions and architectures has potential, especially in scenarios where repeated fine-tuning is computationally prohibitive.
summary: This paper introduces PORTLLM, a framework designed to maintain the effectiveness of domain-specific adaptations in Large Language Models (LLMs) across updates without requiring further fine-tuning. The framework leverages task-specific model patches, derived as the difference between a fine-tuned model and its base (pre-trained) version, to transfer knowledge from one version of an LLM to the next. Experiments demonstrate the method’s effectiveness in enhancing the performance of updated LLMs on various tasks. The approach is claimed to offer computational efficiency and portability across model architectures.
weaknesses: 1. The core idea of leveraging parameter differences between fine-tuned and pre-trained models (task vectors) has been explored in prior work, such as Ilharco et al. (2022) on task arithmetic. PORTLLM builds on this concept, but without substantial theoretical or empirical advancements, the framework’s contribution may be seen as incremental rather than groundbreaking. In light of the established work on task vectors, PORTLLM’s innovation could be questioned.

Ilharco, Gabriel, et al. “Editing models with task arithmetic.” arXiv preprint arXiv:2212.04089 (2022).

2. From the results in Tables 2 and 4, it is evident that the PortLLM method is effective in enhancing the performance of the Updated LLM. However, in most cases, it does not surpass the performance of the Fine-tuned LLM. Moreover, since the PortLLM approach requires access to the parameters of the Fine-tuned LLM to calculate $\Delta \theta$ (task vector), applying PortLLM depends on the existence of a Fine-tuned model. In this setup, if PortLLM cannot consistently outperform the Fine-tuned LLM in terms of performance, its practical application value becomes limited.

---

confidence: 4
contribution: 2
initial_rating: 5
presentation: 2
questions: Hope the authors can expand the experiments based on the identified weaknesses and revise the writing and theoretical analysis accordingly.
soundness: 3
strengths: 1. The training-free framework proposes the reuse of existing adapters after updating large language models and validates its feasibility, effectively reducing training costs.

2. Extensive experiments across multiple datasets and architectures provide strong evidence for the method’s effectiveness. The paper encompasses a broad range of tasks and models, demonstrating its generalizability and robustness across diverse scenarios.
summary: This paper hypothesizes that the rank of adapters trained with LoRA for a specific downstream task is significantly lower than that of adapters obtained through continued pre-training of large language models using LoRA. The authors experimentally validate this hypothesis and further demonstrate that for pre-trained large language models, using the original adapter fine-tuned for a specific downstream task with LoRA does not lead to significant performance degradation after continued pre-training; in fact, there may even be an improvement in performance on downstream tasks. The performance is comparable to that achieved by training new adapters on the updated large language model. This conclusion suggests that after continued pre-training, the original adapters can still be effectively utilized, significantly reducing training costs.
weaknesses: 1. The background and related work sections contain excessive irrelevant content.

2. In the experimental setup, the fine-tuning for downstream tasks is limited to a rank of 8 without further experimentation.

3. In the experimental setup, the continued pre-training involves only the use of different pre-training datasets for training, without addressing the scenario claimed by the authors: that large language models are updated periodically. In such updates, there may be conflicts between new knowledge that develops over time and existing knowledge, potentially leading to significant changes in the model. The authors did not consider this situation.

4. In the theoretical analysis section, it is better to check the statement that $ \( \theta' = \theta + \Delta\theta \)$ ensures $ \( \text{rank}(\theta') \geq \text{rank}(\theta) \) $.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 4
questions: See above.
soundness: 3
strengths: - A training-free framework for transferring domain-specific knowledge between evolving LLM versions through portable model patches
Theoretical analysis justifying why model patches work effectively, showing certain terms can be neglected to create simplified, training-free patches
- Comprehensive empirical validation across multiple tasks ranging from QA to complex reasoning and different model architectures
- Significant efficiency gains compared to LoRA fine-tuning
summary: This paper presents PORTLLM, a novel training-free framework that enables the transfer of personalized knowledge between different versions of evolving LLMs. The key innovation is the creation of lightweight model patches that can be seamlessly applied to updated LLMs without requiring fine-tuning. The framework is extensively evaluated across seven tasks and multiple model architectures, demonstrating comparable or superior performance to LoRA fine-tuning while significantly reducing computational costs. The authors also provide theoretical justification for the portability of their model patches.
weaknesses: I don't identify major weakness, but I do have a few concern regarding the experimental setting:
- In the experiments, seems the authors only focus on small-scale open-source LLMs. However, from my understanding, it could also be more beneficial for large-scale commercial LLMs. 
- Following the previous setting, a few related works adaptation related works might be considered as related works besides LoRA, LMaaS (Sun et al., 2022), kNN-Adapter (Huang et al., 2023), CombLM (Ormazabal et al., 2023), IPA (Lu et al., 2023), Proxy-Tuning (Liu et al., 2024), and BBox-Adaptor (Sun et al., 2024).
- It is interesting to observe that in some cases it even performs better than fine-tuned models. More explanations on potential reasons could benefit this work.
- Echo my previous questions on experimental settings, I think a better evaluation benchmarks lie in (1) personalization tasks, like LaMP; (2) domain-specific adaptation tasks.
- Any thoughts on rigorous theoretical bounds on performance guarantees?

Meta-review: The paper presents PortLLM, a training-free framework that allows for the personalization of evolving LLMs without the need for repeated fine-tuning. The key innovations are the creation of lightweight model patches that can be applied to updated LLMs to transfer domain-specific knowledge, and the theoretical justification for the effectiveness of these patches across model updates. 

*Key strengths:*
- Novelty of the training-free framework for maintaining personalized performance as LLMs evolve
- Comprehensive empirical validation across multiple tasks, from simple QA to complex reasoning, and diverse model architectures
- Significant efficiency gains compared to fine-tuning approaches like LoRA
- Theoretical analysis justifying the effectiveness of the model patches

*main weaknesses and missing aspects:*
- The relationship between the proposed method and prior work on task vectors/arithmetic could be clarified further
- The performance of the method compared to fine-tuned models is not consistently superior, and the practical value proposition needs to be emphasized
- Evaluation on larger, commercial-scale LLMs would strengthen the impact
- Deeper analysis of the approximation error introduced by the method and its impact on performance would be valuable

The reviewers are generally positive about the paper and believe it makes a meaningful contribution, with the average rating being marginally above the acceptance threshold. The key reasons for this decision are:
- The novelty and practical significance of the training-free personalization framework for evolving LLMs
- The strong empirical results demonstrating the efficacy of the approach
- The theoretical underpinnings provided by the authors
- The potential for the method to have significant impact, especially for scenarios with limited resources for repeated fine-tuning

Overall, the paper appears to be a solid contribution to the field of efficient fine-tuning and personalization of large language models.

Decision: Accept (Poster)