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

Rana Shahroz, Pingzhi Li, Sukwon Yun, Zhenyu Wang, Shahriar Nirjon, Chau-Wai Wong, Tianlong Chen

TL;DR PortLLM introduces a training-free framework that allows users to "patch" newly updated large language models (LLMs) with domain-specific knowledge captured from older versions. By treating fine-tuned weights as portable patches, it achieves performance comparable to full re-training with up to a 12.2× reduction in GPU memory and near-instant deployment.

The Moving Target Problem

In the fast-moving world of AI, LLMs are constantly evolving. Providers frequently release updated versions of models (e.g., transitioning from Llama 2 to Llama 3, or pushing periodic updates to ChatGPT) through continued pretraining. For developers who have spent weeks fine-tuning a model on specialized data—such as medical records or legal documents—these updates present a frustrating dilemma:

  1. Obsolescence: Stick with the old, fine-tuned model and miss out on the general reasoning improvements of the new base model.
  2. Expense: Re-fine-tune the new model from scratch, which is computationally expensive and time-consuming.
  3. Data Vanishing: In sensitive sectors, the original fine-tuning data might no longer be accessible due to privacy regulations or expiring licenses.

The authors ask a critical question: Can we take the "knowledge" we already learned for the old model and simply plug it into the new one without any new training?

The PortLLM Framework

The researchers propose PortLLM, a framework based on the observation that Low-Rank Adaptation (LoRA) weights are surprisingly portable across model versions.

PortLLM Framework Comparison

Standard LoRA fine-tuning represents a weight update as a low-rank matrix addition. PortLLM's core hypothesis is that if you have an old base model ($\theta$) and a new, evolved version ($\theta'$), you can approximate the "perfectly fine-tuned" version of the new model by simply adding the old model's task-specific patch ($\Delta \theta_i$) to the new base:

$$\theta'_i \approx \theta' + \Delta \theta_i$$

This is a training-free merge. Instead of running backpropagation on the new model, you simply perform a weight addition. The paper provides a theoretical justification using Singular Value Decomposition (SVD), proving that because the rank of the personalization patch is much smaller than the rank of the model's general evolution, the "error" introduced by this naive merging is mathematically negligible.

Key Insights and Results

The authors validated PortLLM across a wide array of tasks (including BoolQ, SST-2, MRPC, WinoGrande, and GSM8K), evolution scenarios, and base models (Mistral-7B, Llama-2-7B, Llama-3.1-8B, and Gemma-2-9B).

  • The "Portability" Discovery: Task-specific knowledge (the "patch") is largely independent of the minor shifts in weights that occur during continued pretraining. The patch "knows" how to do the task, and the base model "knows" the language; they can be combined post-hoc.
  • Synergy, Not Just Preservation: In several cases, the patched model actually outperformed the original fine-tuned model. This suggests that the patch can leverage the improved general reasoning of the evolved base model to execute the specific task even better.
Performance across downstream tasks

Empirically, PortLLM delivers massive efficiency gains. It reduced GPU memory usage by up to 12.2× compared to LoRA fine-tuning, turning hours of training into seconds of merging. On the complex GSM8K reasoning task, PortLLM achieved 41.32% accuracy, significantly higher than both the original fine-tuned model (34.04%) and the updated base model (15.16%). Across all seven datasets, applying the "old" patch to the "new" model resulted in substantial zero-shot performance jumps over the base model without requiring a single step of gradient descent.

Limitations and Future Work

While PortLLM is a breakthrough for "evolving" models (same architecture, updated weights), it has clear boundaries:

  • Architectural Constraints: The paper does not demonstrate portability across different architectures (e.g., taking a Mistral patch and putting it on a Llama model). Since the weight dimensions and internal representations differ, a simple merge wouldn't work.
  • LoRA Dependency: The method relies on the availability of low-rank adapters. If a model was fine-tuned using full-parameter updates, extracting a "patch" is much more complex.

Future work will likely explore more sophisticated model merging techniques beyond simple addition to further reduce residual error and potentially enable cross-architecture knowledge transfer.

Summary updated

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× 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.
BibTeX
@inproceedings{shahroz2025portllm,
  author = {Rana Shahroz and Pingzhi Li and Sukwon Yun and Zhenyu Wang and Shahriar Nirjon and Chau-Wai Wong and Tianlong Chen},
  title = {{PortLLM: Personalizing Evolving Large Language Models with Training-Free and Portable Model Patches}},
  booktitle = {International Conference on Learning Representations},
  year = {2025},
  url = {https://openreview.net/forum?id=gyHoR6uFhU},
}
Figure