Model Recycling in Transfer Learning

• Model Recycling Framework is a paradigm that reuses pre-trained models, prompts, and task-specific modules to enhance transfer learning and downstream robustness.
• It employs methods such as weight-space averaging, prompt transformation, and module-mixing to improve out-of-distribution accuracy and reduce training overhead.
• The framework also influences reproducible ML systems and even numerical linear algebra by recycling latent structures to boost efficiency and reliability.

Searching arXiv for papers on “model recycling framework” and closely related model recycling methods. Model Recycling Framework denotes a family of research programs in which previously trained models, task-specific modules, prompts, or other model-derived artifacts are treated as reusable assets rather than terminal endpoints. In recent arXiv usage, the term is most explicit in multi-source data-free supervised transfer learning, where a labeled target task is solved using only a library of pre-trained source models and no source-domain data, and in transfer-learning schemes that recycle multiple fine-tunings of the same foundation model to improve downstream robustness (Wang et al., 4 Aug 2025, Ramé et al., 2022). Closely related work extends the same principle to soft prompts for frozen LLMs and to reproducible ML platforms in which data, feature, scoring, and evaluation transformations are preserved as reusable artifacts (Lester et al., 2022, Sugimura et al., 2018).

1. Core idea and conceptual scope

At its most general, a model recycling framework replaces one-shot transfer with structured reuse. Instead of selecting a single source checkpoint and fine-tuning it conventionally, the framework identifies reusable information already encoded in prior artifacts and redeploys that information under new objectives. In the transfer-learning literature, the recyclable object may be a full fine-tuned model, a task-specific module, a prompt vector, a feature extractor, or a stored transformation graph. In numerical linear algebra, an analogous idea appears as reuse of approximate invariant subspaces across related systems, which is a broader but structurally similar notion of recycling (Ahuja et al., 2010, Ahuja et al., 2014).

A recurring motivation is that isolated fine-tuned models constitute a missed opportunity. One paper states that the internet is populated by many fine-tunings of the same foundation model on diverse auxiliary tasks, and argues that these specialized checkpoints contain rich and diverse features that can be reused rather than discarded (Ramé et al., 2022). Another paper frames pre-trained models as “recycling materials” in a library setting, where the primary problem is to identify subsets of related source models without source data and to adapt them efficiently to a labeled target task (Wang et al., 4 Aug 2025). A third paper poses the analogous question for parameter-efficient tuning artifacts: if a frozen LLM is updated, can a learned prompt be transformed to work with the new target model without re-tuning from scratch (Lester et al., 2022).

Recycled object	Representative mechanism	Representative papers
Fine-tuned checkpoints	Parallel target fine-tuning from diverse auxiliary initializations, then weight averaging	(Ramé et al., 2022)
Soft prompts	Embedding-space transformation $r(P_s)\rightarrow P'_t$	(Lester et al., 2022)
Source models without source data	Related-source selection plus module-mixing	(Wang et al., 4 Aug 2025)
Pipeline artifacts	Reuse of data, feature, scoring, and evaluation transformations	(Sugimura et al., 2018)

This suggests an editor’s term, “artifact-level reuse,” for the common abstraction: recycling targets whatever intermediate object most economically preserves task-relevant structure.

2. Weight-space recycling of fine-tuned models

A canonical weight-space formulation is Model Ratatouille, which starts from a foundation model checkpoint, fine-tunes it on multiple auxiliary tasks, replaces each auxiliary classifier by a shared target-task linear probe, fine-tunes each branch on the target task, and returns the final model by parameter-wise averaging $\sum_{i=0}^{M-1}\lambda_i\theta_i$ with either uniform or greedy coefficients (Ramé et al., 2022). The appendix states the compact recipe as

$$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$

and contrasts it with vanilla fine-tuning, model soups / DiWA, inter-training, and fusing. The distinctive feature is delayed averaging: target-task branches are not initialized identically, but from different auxiliary-task-adapted featurizers.

The framework is justified by three ingredients: individually accurate branches, diversity across branches, and averageability through linear mode connectivity. The paper formulates two hypotheses: linear mode connectivity between auxiliary featurizers paired with a shared linear probe, and linear mode connectivity between final target-task models that started from different auxiliary initializations. Empirically, diversity is measured using $1-Q$, where

$$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$

and greater diversity is positively correlated with larger OOD gains from weight averaging. The method is therefore not generic model averaging; its novelty lies in structured reuse of compatible auxiliary specializations rather than mere stochastic variation.

On DomainBed, the main table reports 68.1 average OOD accuracy for Model Ratatouille (uniform), compared with 67.6 for model soups (uniform), 66.9 for SWAD, and 65.6 for vanilla fine-tuning in the authors’ run setting. Averaging over three splits, Ratatouille reaches 68.3. Dataset-level gains are especially clear on PACS, where Ratatouille greedy reaches 90.5, and on OfficeHome, where Ratatouille greedy reaches 73.4; Camelyon appendix results also improve over soups, with 94.6 versus 94.3 for uniform and 95.4 versus 95.1 for greedy (Ramé et al., 2022). The paper emphasizes that if auxiliary checkpoints already exist online, the method adds no more training overhead than a normal hyperparameter search and yields a single averaged model with no inference-time overhead.

3. Prompt, module, and feature recycling

Prompt recycling studies the same problem at the level of parameter-efficient artifacts. A source prompt $P_s$, trained on a frozen source model $M_s$ for task $T$, is transformed by a recycler $r$ into a recycled target prompt $P'_t$ for a new frozen target model $\sum_{i=0}^{M-1}\lambda_i\theta_i$0,

$\sum_{i=0}^{M-1}\lambda_i\theta_i$1

under strict constraints: no supervised prompt pairs, no task-specific data, and no tuning updates on the target model after recycling (Lester et al., 2022). The paper proposes three concrete recyclers. In vocabulary-to-vocabulary linear transfer, a least-squares map $\sum_{i=0}^{M-1}\lambda_i\theta_i$2 is learned from token embeddings so that $\sum_{i=0}^{M-1}\lambda_i\theta_i$3, then applied to the prompt,

$\sum_{i=0}^{M-1}\lambda_i\theta_i$4

In the nonlinear variant, $\sum_{i=0}^{M-1}\lambda_i\theta_i$5 is a small neural network from $\sum_{i=0}^{M-1}\lambda_i\theta_i$6 to $\sum_{i=0}^{M-1}\lambda_i\theta_i$7. In linear-combination transfer, the source prompt is decomposed as $\sum_{i=0}^{M-1}\lambda_i\theta_i$8, and the same coefficients are applied to the target vocabulary, $\sum_{i=0}^{M-1}\lambda_i\theta_i$9. These methods treat prompt vectors as embedding-space objects whose geometry may remain partially aligned across model updates.

The empirical picture is mixed but concrete. The paper reports that its best settings are able to “successfully recycle 88.9\% of prompts,” referring to the proportion of recycled prompts that outperform the target model’s zero-shot baseline in a specific IMDB-to-Large setting. Aggregated results in Table 1 show that for Base targets on SST2, Re-Tune reaches $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$0, Zero-Shot is $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$1, Recycle is $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$2, and random prompts average $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$3; for Base targets on IMDB, Recycle reaches $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$4 against Zero-Shot $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$5 and random $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$6. For Large targets, recycling often beats zero-shot but can underperform random prompts on average because failures are severe. The paper explicitly notes a remaining gap of roughly 15 points to direct retuning in strong settings, and shows that recycled prompts used directly for autoregressive generation often produce illegal outputs, frequently ".", indicating a separation between transferred task preference structure and output-format control (Lester et al., 2022).

A broader module-level formulation appears in multi-source data-free supervised transfer learning. Here the learner has access only to a labeled target dataset and source models $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$7, with no source data; each source model is written as $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$8, and source and target label spaces need not match because the source models are primarily reused as feature extractors (Wang et al., 4 Aug 2025). The framework first scores each source model by $$\theta = \frac{1}{M} \sum_{i=0}^{M-1} \mathrm{Train}(\mathrm{Train}(\theta^{\mathrm{pt}}, T_i), T),$$9-NN validation accuracy on target features, then selects the top-$1-Q$0 related sources, and finally adapts them through module-mixing. In the white-box case, each target task-specific layer is a convex combination of selected source modules and a new randomly initialized module,

$1-Q$1

while the output feature representation is mixed as

$1-Q$2

The framework also adds a distance-correlation penalty and optimizes

$1-Q$3

with $1-Q$4. On Office-31, the best white-box variant with $1-Q$5 and distance-correlation loss reaches 95.14 AVG, a gain of 7.75\% over Finetune Source at 87.39 AVG. In black-box CIFAR100 transfer, the API-source variant reaches 71.80 AVG, exceeding independent training at 70.39 and model stacking at 70.88 (Wang et al., 4 Aug 2025).

4. Infrastructure, compatibility, and reusable system design

Model recycling frameworks typically require explicit compatibility management. In the multi-source source-free setting, white-box reuse assumes source models share a predefined architecture and compatible task-specific modules; black-box reuse relaxes architectural identity but requires access to source features before the classification head, followed by dimensional alignment with FastICA. The same paper proposes Efficient Feature Transformation as the task-specific module design, and reports that for ResNet-18 with $1-Q$6 and $1-Q$7, each task requires about 449k parameters, which is 3.9\% of the backbone size (Wang et al., 4 Aug 2025). This is a library-oriented design: one frozen shared backbone can support many compact modules, which a Model as a Service provider can store and later recycle.

A complementary infrastructure perspective comes from reproducible ML systems. One framework is organized into four layers—data, feature, scoring, and evaluation—each composed of well defined transformations, so that a model can be exactly replicated and the transformations can be reused across different models (Sugimura et al., 2018). The feature layer is version-controlled and treats implemented features as immutable; if a bug is fixed, a new feature is created rather than mutating the old one. The scoring layer saves a model config file containing feature definitions, algorithm hyperparameters, and preprocessing details such as missing value imputation, scaling, and outlier removal, together with timestamp, random seed, all training information and the trained model itself, hashes of those files, and a hash of the config appended to the filename. This is not weight recycling in the narrow sense, but it establishes the lineage and artifact stability without which later reuse is unsafe.

The same logic appears operationally in ensemble DAGs. If multiple downstream models depend on the same feature set, the scoring layer requests that feature set only once. A plausible implication is that mature model recycling systems require not only reusable model parameters, but also reusable metadata, dependency graphs, and audit trails. In practice, compatibility constraints therefore span architecture, layer shapes, tokenization or vocabulary alignment, source-target representation geometry, and provenance of the transformations that produced the original artifact.

5. Mathematical generalizations beyond machine-learning transfer

A broader technical meaning of recycling appears in Krylov-subspace methods, where what is recycled is not a checkpoint but low-dimensional spectral structure. Recycling BiCG studies sequences of dual linear systems

$1-Q$8

and introduces left and right recycle spaces $1-Q$9 and $$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$0, with projected images $$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$1 and $$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$2, to accelerate later solves while preserving the Petrov–Galerkin structure that is valuable in interpolatory model reduction (Ahuja et al., 2010). The augmented recurrences operate on projected operators and update approximate solutions of the form

$$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$3

Recycle spaces are updated from harmonic Ritz information via a small generalized eigenvalue problem. In an IRKA model-reduction example, the method shows up to 70\% savings in iterations, and for a model reduction problem BiCG takes about 50\% more time than recycling BiCG (Ahuja et al., 2010).

Recycling BiCGSTAB extends the same design to sequences of single non-symmetric systems while retaining BiCGSTAB’s short-term recurrences. The projected operator is

$$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$4

and the method embeds recycle-space projection into each matrix-vector product while tracking the recycle-space contribution separately. In a parametric model order reduction workflow, the reported gains are about 40\% savings in the number of matrix-vector products and about 35\% savings in runtime (Ahuja et al., 2014). This broader usage suggests that model recycling can be viewed abstractly as extraction, compression, and redeployment of latent structure that varies slowly across problem instances, whether that structure is weight-space diversity, prompt geometry, feature manifolds, or invariant subspaces.

6. Performance boundaries, misconceptions, and research directions

Several misconceptions recur across the literature. Model recycling is not synonymous with generic ensembling or checkpoint averaging: Model Ratatouille is distinguished from soups by the fact that each target-task branch starts from a different auxiliary-task specialization rather than a shared initialization (Ramé et al., 2022). It is not equivalent to simple source-free adaptation: the multi-source framework first performs related-source identification, then learns a weighted module or feature combination over a selected subset (Wang et al., 4 Aug 2025). It is also not a substitute for retraining in all high-performance settings: prompt recycling remains substantially below direct retuning, and the strongest results still leave roughly a 15-point accuracy deficit relative to target-model retuning (Lester et al., 2022).

Failure modes are correspondingly specific. Prompt recycling works best when source and target models are related enough to admit stable embedding correspondences, when the target model already has nontrivial zero-shot competence, and when the source prompt has not overfit too far into source-specific idiosyncrasies; training longer can reduce recyclability even when source-task performance improves (Lester et al., 2022). Weight-space recycling can fail when auxiliary tasks are too unrelated and linear mode connectivity breaks; greedy selection based on IID validation may discard useful diversity and hurt OOD performance (Ramé et al., 2022). Multi-source source-free transfer remains sensitive to hyperparameters and mixing-weight initialization, and larger $$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$5 is not uniformly better; in CTrL, $$Q=\frac{N^{11}N^{00}-N^{01}N^{10}}{N^{11}N^{00}+N^{01}N^{10}},$$6-NN source selection is decisive, while random source choice yields almost no benefit (Wang et al., 4 Aug 2025).

The main research directions are therefore already visible. One line seeks better transferability estimation and mixing initialization, since current source selection in source-free transfer is intentionally simple. Another seeks broader compatibility, especially beyond shared architectures or shared tokenizers. A third seeks recyclable artifacts that are “recyclability-aware by construction,” for example through initialization or regularization that preserves cross-model structure without sacrificing task performance. A fourth concerns infrastructure: reusable model libraries become substantially more credible when coupled to versioned, immutable, and hash-linked transformation stacks of the kind described in reproducible ML pipelines (Sugimura et al., 2018). Taken together, these works define Model Recycling Framework not as a single algorithm, but as a systems-and-algorithms paradigm in which learned artifacts are designed, selected, transformed, and recombined for repeated downstream use rather than being discarded after their first deployment.