Don't Start Over: A Cost-Effective Framework for Migrating Personalized Prompts Between LLMs

AI summary

Overview

• Research area: Natural Language Processing — personalization in large language models, parameter-efficient fine-tuning, and soft prompt transfer.
• Technical level: Advanced. The paper assumes familiarity with soft prompts, adapter modules, parameter-efficient fine-tuning, coreset selection, and recommendation-style evaluation metrics (RMSE, MAE, AUC, uAUC).
• One-sentence scope: The paper introduces PUMA, a lightweight adapter-plus-user-sampling framework that migrates thousands of user-specific soft prompts from an old LLM to a new, architecturally incompatible LLM at a fraction of the cost of retraining them from scratch.

What This Paper Is About

Personalized LLM applications often attach a separate soft prompt to each user inside a "1+N" system — one shared frozen foundation model plus N user-specific prompts. When the foundation model is upgraded or swapped, those prompts become semantically incompatible and normally must all be retrained from scratch, which is prohibitively expensive. PUMA attacks this by learning a single supervised mapping function that translates source-model prompts into prompts the target model can use, and by training that mapping on a small, carefully chosen subset of users rather than the whole population.

Key Contributions

1. The paper identifies and formalizes, for the first time according to the authors, the problem of migrating user-level personalized soft prompts across foundation models — distinct from prior task-level prompt transfer work, which the authors characterize as "one-to-one" or "few-to-one" rather than "N-to-N."
2. It proposes PUMA (Prompt-level User Migration Adapter), a lightweight feed-forward adapter with residual connections and Layer Normalization, trained end-to-end on the task loss while the target model and source prompts stay frozen.
3. It introduces a group-based user selection strategy: K-means clustering on source prompt embeddings for diversity, then variance-based stratified sampling within each cluster to capture the spectrum of user complexity.
4. It validates the framework on three large-scale datasets across five model architectures and two advanced topologies (chained and aggregated migration), reporting that PUMA matches or surpasses full retraining while cutting computation by up to 98%.

Main Findings

• PUMA beats full retraining on all three datasets. On Amazon, PUMA reaches RMSE 0.9135 versus 0.9414 for full retraining, and MAE 0.5701 versus 0.6296. On Yelp, RMSE is 1.1073 versus 1.1994 and MAE 0.8493 versus 0.9269. On MIND, uAUC rises from 0.5289 (full retraining) to 0.6552, and AUC from 0.5778 to 0.6546.
• Random initialization is far worse. Randomly initialized prompts yield Amazon RMSE 1.2352, MIND AUC 0.4917, Yelp RMSE 1.6671, establishing the lower bound.
• The adapter has 88.1M trainable parameters, per Table 2, while the source and target models and all source prompts remain frozen.
• 50x training speedup. On Amazon, full retraining takes 3.00 hours per epoch for 8 epochs (24.0 hours total), while PUMA with 2,000 users takes 0.16 hours per epoch for 3 epochs (0.48 hours total) — a 50x speedup, consistent with the reported up-to-98% cost reduction.
• The selection strategy beats random sampling at the same budget. Under a fixed budget of 2,000 users for Amazon/Yelp and 1,500 for MIND, PUMA's "K-Means + Variance Stratification" achieves Amazon RMSE 0.9315 with 2,000 users, better than the "Random (6k)" baseline at 0.9320 with three times as many users.
• Naive random sampling needs roughly 5,000 users on Amazon merely to match the RMSE of full retraining, which the authors use to argue that unguided sampling is computationally prohibitive.
• Ablations on embedding choice. Clustering on FFN activations (concatenated activations from the source model's final three FFN layers) rather than on soft prompts produced weaker results: K-Means on FFN Activations gave Amazon RMSE 0.9373, and adding loss stratification gave 0.9467, versus 0.9315 for PUMA.
• Generalization across model families holds. In the generalization and RQ4 experiments the training set was fixed at 6,000 users, and migrations between distinct model families (Llama3.2-3B-Instruct, Qwen2.5-3B-Instruct, Stablelm-2-1_6b-chat, Phi-3-mini-4k-instruct, Gemma-3-1b-it) consistently yielded gains, with efficacy bounded by the quality of the source prompts.
• Chained migration is stable. Across Llama3.2 → Qwen2.5 → Gemma-3 → StableLM-2 → Phi-3, RMSE started at 0.9348 and ended at 0.9277, outperforming retraining from scratch at each stage; a minor dip occurred when migrating from Gemma, attributed to moving to a comparatively weaker model.
• Aggregated migration improves results. Fusing prompts from two sources into Phi-3 with "Llama + StableLM" produced RMSE 0.9217, better than migrating from Llama alone (0.9293) or StableLM alone (0.9380).
• Source-model performance is reported as a reference row (Amazon RMSE 0.9438, MAE 0.6306; MIND AUC 0.5742, uAUC 0.5312; Yelp RMSE 1.2005, MAE 0.9369).

Methodology in Plain English

The authors start with a frozen source model that already has a trained soft prompt for every user. When a new target model is chosen, they do not touch the target model's weights or the original prompts. Instead they train a small adapter network whose only job is to transform each source prompt vector into a vector the target model can consume, even when the two models have different embedding dimensions. The adapter is trained end-to-end by feeding the transformed prompts into the target model and minimizing the same task loss the original prompts were trained on.

Because training on every user is too expensive, they first shrink the user pool. They run K-means over the source prompt vectors so the chosen users span the space of learned preferences; within each cluster they stratify users by how variable their historical outputs are, and sample with a normal-distribution weighting that favors medium-variance groups. Low-variance users are easy, high-variance users are hard, and the adapter needs examples across that spectrum. For advanced cases, they concatenate a user's prompts from multiple source models before mapping, so one target model can absorb knowledge from several predecessors.

Experiments use three datasets: Amazon (Movies & TV) with 30,287 users, 96,636 items and 1,166,752 records; MIND with 50,000 users, 19,368 items and 3,892,068 records (17.80% positive ratio); and Yelp with 32,850 users, 129,076 items and 1,543,687 records. Rating tasks use RMSE and MAE; the MIND CTR task uses AUC and user-weighted AUC. The default migration is Llama-2-1B-Instruct to Llama-2-3B-Instruct. Source prompts of length l=1 are pre-trained for 15 epochs at learning rate 5×10⁻⁴; the adapter trains for 4 epochs with FusedAdam at 1×10⁻⁴ and batch size 32 on NVIDIA A100 GPUs with PyTorch 2.5. Rating loss is 0.8·MSE + 0.2·cross-entropy over the five rating tokens; MIND uses binary cross-entropy on the "yes" token logit.

Why This Matters

Research impact. The paper reframes prompt migration from a per-user maintenance chore into a single learned transformation problem, and it opens a new problem setting — user-level, N-to-N prompt migration — that sits apart from the existing task-level soft prompt transfer literature. Its finding that one shared adapter can outperform thousands of independently retrained prompts suggests that cross-model mapping generalizes better than isolated per-user learning.

Real-world applications.

• Personal assistants and chatbots that store a per-user soft prompt and must survive a foundation-model upgrade without losing accumulated user preferences.
• Recommendation and content-ranking systems, the setting this paper directly tests, where user representations are learned and expensive to rebuild.
• Adaptive education platforms that carry individual learner profiles across model generations.
• Enterprise systems that consolidate user assets after a merger, an A/B test, or a multi-vendor deployment, via the aggregated migration setting.

Industry relevance. The 98% cost reduction and 50x training speedup matter for operators running large user bases, because the alternative — retraining every user prompt — scales linearly with user count. Decoupling user assets from the underlying model also reduces lock-in to a single model vendor and makes routine model upgrades inexpensive to absorb.

Future Directions

• Replace the static heuristic selection (K-means plus variance stratification) with a learned selection policy, possibly trained with reinforcement learning, to discover better user subsets than fixed heuristics allow.
• Extend migration beyond user prompts to item embeddings, so both sides of a personalized system transfer together.
• Handle cold-start personalization, using the trained adapter to quickly initialize prompts for users who did not exist in the source system.
• Continue testing more complex and realistic migration topologies beyond the chained and aggregated settings examined here.

Target Audience

Researchers and engineers working on LLM personalization, parameter-efficient fine-tuning, prompt tuning, and recommender systems will get the most from this paper. It is also relevant to platform engineers who operate "1+N" deployments with per-user adapters and need a practical plan for model upgrades, and to readers interested in coreset selection as applied to user-level rather than sample-level data. Prerequisites include comfort with adapter architectures and the recommendation metrics used in the evaluation. Code is available at https://github.com/Kimagure7/Dont-Start-Over, and the authors are affiliated with the University of Science and Technology of China, the National University of Singapore, and Huawei Technologies.

Authors’ abstract

Personalization in Large Language Models (LLMs) often relies on user-specific soft prompts. However, these prompts become obsolete when the foundation model is upgraded, necessitating costly, full-scale retraining. To overcome this limitation, we propose the Prompt-level User Migration Adapter (PUMA), a lightweight framework to efficiently migrate personalized prompts across incompatible models. PUMA utilizes a parameter-efficient adapter to bridge the semantic gap, combined with a group-based user selection strategy to significantly reduce training costs. Experiments on three large-scale datasets show our method matches or even surpasses the performance of retraining from scratch, reducing computational cost by up to 98%. The framework demonstrates strong generalization across diverse model architectures and robustness in advanced scenarios like chained and aggregated migrations, offering a practical path for the sustainable evolution of personalized AI by decoupling user assets from the underlying models.