Identifying and Reusing Learnwares Across Different Label Spaces

Identifying and Reusing Learnwares Across Different Label Spaces

Jian-Dong Liu1,2 , Zhi-Hao Tan1,2 and Zhi-Hua Zhou1,2

1National Key Laboratory for Novel Software Technology, Nanjing University, China 2School of Artificial Intelligence, Nanjing University, China

{liujd, tanzh, zhouzh}@lamda.nju.edu.cn

Abstract

The learnware paradigm focuses on leveraging

numerous established high-performing models to

solve machine learning tasks instead of starting

from scratch. As the key concept of this paradigm,

a learnware consists of a well-trained model of any

structure and a specification that characterizes the

model's capabilities, allowing it to be identified and

reused for future tasks. Given the existence of nu-

merous real-world models trained on diverse la-

bel spaces, effectively identifying and combining

these models to address tasks involving previously

unseen label spaces represents a critical challenge

in this paradigm. In this paper, we make the first

attempt to identify and reuse effective learnware

combinations for tackling learning tasks across dif-

ferent label spaces, extending their applicability

beyond the original purposes of individual learn-

wares. To this end, we introduce a statistical class-

wise specification for establishing similarity rela-

tions between various label spaces. Leveraging

these relations, we model the utility of a learnware

combination as a minimum-cost maximum-flow

problem, and further develop fine-grained learn-

ware identification and assembly methods. Exten-

sive experiments with thousands of heterogeneous

models validate our approach, demonstrating that

reusing identified learnware combinations can out-

perform both training from scratch and fine-tuning

a generic pre-trained model.

1 Introduction

Machine learning has achieved significant success in various practical fields, including medicine, robotics, and ecology. However, in classic machine learning paradigm, training a well-performing model from scratch still requires several challenging conditions, such as sufficient labeled data, adequate computational resources, and proficient training skills. Additionally, privacy and proprietary concerns obstruct data sharing among developers, limiting the potential of big models in many data-sensitive scenarios.

To tackle these issues simultaneously, learnware [Zhou, 2016; Zhou and Tan, 2024] was proposed for solving machine learning tasks in a novel paradigm. In this context, a learnware consists of a well-performing model of any structure and a specification which captures the model's specialty and utility in a certain representation, such as its statistical properties. Developers worldwide can submit their models trained on various tasks into a learnware dock system spontaneously, and the system helps generate specifications for each model to form learnwares. When facing a new user task, the system can identify and assemble helpful learnwares from all existing learnwares based on their specifications. The user can then reuse these learnwares with her own data to address her task instead of starting from scratch. It is important to note that the learnware dock system should not access the raw data of either model developers or users.

To realize the vision depicted above, the critical challenge of learnware paradigm is to effectively identify and assemble useful learnwares within a learnware dock system for new user tasks, without accessing raw data. The key to the solution is specification, the core of this paradigm. Recently, the reduced kernel mean embedding (RKME) specification [Zhou and Tan, 2024] was proposed, characterizing model capabilities via distribution information. Based on this specification, several learnware search and reuse algorithms have been developed, and the efficacy of specificationbased model selection and combination has been empirically and theoretically verified [Wu et al., 2023; Liu et al., 2024; Tan et al., 2024a]. However, considering that numerous existing models and future user tasks come from diverse label spaces, an important problem in the learnware paradigm is still unsolved: how to identify and reuse helpful learnware combinations for user tasks across different label spaces, which greatly limits the scope of the learnware dock system. To illustrate, consider a scenario shown in Figure 1, where a user needs to classify classes such as sheep, deer, horses, and dogs. Although the system does not possess a single learnware trained specifically for classifying these four classes, there exists a learnware combination whose label spaces collectively encompass the user's required label space. If these relevant learnwares can be identified and combined to address the user task, it would significantly expand the scope of user tasks that can be handled, enabling the reuse of the combination beyond the limits of individual learnwares. With the initial learnware dock system recently built [Tan et al., 2024b], tackling this problem has become more crucial.

In practice, the fundamental challenges of this problem mainly stem from two aspects: the unknown correspondence between different label spaces of learnwares and the user task, and the inability of the system to access raw data from model developers or users. Although accurate semantic information about each label space would make the problem easier, obtaining such information is particularly difficult due to the inherent ambiguity of natural language, the enormous number of learnwares in the system, and the additional complexity imposed on users in describing their requirements.

In this paper, to overcome these challenges without leveraging semantic information, our key insight is to represent model capabilities with statistical class-wise specifications and model the utility of a learnware combination to a user task from a perspective of class matching, thereby establishing relations between label spaces of each learnware and user tasks. Based on these relations, the system can handle user tasks involving previously unseen label spaces by identifying and assembling effective learnware combinations without access to raw user data. These learnwares collectively cover the required label space, providing an effective solution. The main contributions are summarized as follows:

• We make the first attempt to identify helpful learnware combinations across different label spaces to solve user tasks involving previously unseen label spaces, without accessing raw data from model developers or users. This enables the reuse of these combinations beyond the original purposes of individual learnwares, significantly expanding the scope of user tasks that can be handled.
• To represent a model's capabilities on each class, we extend the RKME specification into a class-wise version, capturing the conditional distribution and measuring similarity relations between different label spaces. Leveraging these relations, we model learnware combination utility for user tasks as minimum-cost maximum-
• flow problems, and further develop practical methods for identifying and reusing useful learnware combinations.
• Extensive experiments involving thousands of heterogeneous models validate the efficacy of our approach. Empirical results also show that reusing identified learnware combinations can outperform both training from scratch and fine-tuning a generic pre-trained model.

2 Problem Setup

The learnware paradigm consists of two stages: the submitting and deploying stages.

Submitting Stage. In this stage, N developers submit their models {fi}Ni=1 to the learnware dock system. Each model fi is trained on a dataset Di = (Xi, yi) over X × Yi, where Yi denotes the label space unique to model fi. In settings with heterogeneous label spaces, each model's label space Yi can be distinct. Additionally, along with the well-trained model fi, each developer also provides a specification Si to the system, which is generated with assistance from the system.

Deploying Stage. In this stage, the user possesses an unlabeled dataset Du = Xu defined over X, and the label space associated with her task is Yu, which differs from that of all learnwares, i.e., Yu ̸∈ {Yi}Ni=1 . Since there are various label spaces in the system, the user also has limited m labeled instances for each class in Yu. To tackle Du, the user submits task requirements Ru to the system, which then returns a helpful learnware combination {fi | i ∈ I} with the number constraint |I| ≤ M based on specifications {Si}Ni=1 . Subsequently, the user can solve her task by reusing these learnwares. The constraint about |I| is natural and practical since the computing resources and time required for reusing learnwares are directly proportional to the number of learnwares.

Note that the learnware dock system cannot access raw data of either model developers or users. Besides, due to the decoupling of heterogeneous features and labels, identifying heterogeneous models typically requires finding a unified feature space [Tan et al., 2023; Tan et al., 2024a] before addressing diverse label spaces. Thus, this study assumes all models operate in a unified feature space X and can naturally expand to heterogeneous feature and label spaces in the future.

3 Our Approach

In this section, we first introduce the statistical class-wise specification, which characterizes model capabilities on different classes. Building on this, we then detail our comprehensive solution, focusing on algorithms for learnware identification and reuse.

3.1 CharacterizingModel Capabilities

To effectively identify and assemble suitable model combinations across heterogeneous label spaces, the first step is to precisely characterize model capabilities on different classes. However, the lack of access to raw data frommodel developers or users poses a significant challenge.

The cornerstone of our solution is specification. While the RKME specification [Zhou and Tan, 2024] has shown efficacy in several learnware studies [Liu et al., 2024; Tan et al.,

2024a] by capturing the entire data distribution, the recent implementation [Wu et al., 2023] falls short in modeling the conditional data distribution for each class, restricting its efficacy in heterogeneous label space settings. To address this, we extend RKME into a class-wise version, the class-wise RKME specification, incorporating conditional distribution information and enabling accurate characterization of model capabilities on each class without exposing raw data.

Let ∆n = {β ∈ Rn | 1⊤β = 1, β ≥ 0} denote the n-dimensional simplex. For each class c ∈ Y, let Xc = [xc,1; xc,2; . . . ; xc,mc ] represent the subset of dataset D belonging to class c and correctly classified by model f. Then the class-wise RKME specification S = {(βc ∈ ∆n ,Zc ∈ X n )}c∈Y is generated by solving:

where k : X × X ↦→ R is a kernel function with reproducing kernel Hilbert space Hk, and ˆµc = 1 mc ∑mc i=1 k(xc,i, ·) is the empirical KME [Smola et al., 2007] of class c. The reduced set size n, much smaller than the size of original dataset D, is empirically set to 10 in experiments. Inspired by [Wu et al., 2023], we solve Eq. (1) using alternating optimization: βc is updated via quadratic programming, while Zc is optimized using gradient descent, as detailed in Algorithm 1.

Since the specification S is an extension of RKME across different classes, it retains the properties of RKME, such as protecting original data and providing robust defense against common inference attacks [Lei et al., 2024]. Furthermore, it incorporates conditional distribution information, as demonstrated in the following proposition with proof in Appendix C.

Proposition 1. Assume supx∈X k(x, x) < ∞. Let ˜µc = ∑nj=1 βc,jk(zc,j , ·). Then, ∀c ∈ Y, we have ∥ˆµc - ˜µc∥Hk = O(n-1/2 ), where n is the reduced set size of specification S.

As the empirical KME ˆµc captures the conditional distribution information of data correctly classified as class c by model f [Smola et al., 2007], Proposition 1 indicates that the specification S accurately characterizes model capabilities on different classes, enabling precise learnware identification. In the submitting stage, each developer generates the class-wise RKME specification Si with system assistance and submits the learnware (fi, Si) without disclosing their raw data.

3.2 Identifying Helpful Learnware Combinations

In the deploying stage, the user submits task requirements Ru to the system, expecting to receive helpful learnwares {fi}i∈I for her task Du, without leaking raw data. To achieve this, we first delve into the design of user task requirements and then present a practical learnware identification method.

User Task Requirements. Similar to model developers, the user can locally generate the class-wise RKME specification Su using her limited m labeled data per class in Yu. To better capture the task's statistical properties, we further enhance the requirements Ru by estimating class probabilities.

For the user task, let Xu ∈ X mu be the unlabeled dataset and {Xc ∈ X m}c∈Yu the labeled dataset. Utilizing kernel mean embedding techniques [Smola et al., 2007], we can estimate class probabilities w ∈ ∆|Yu| by solving the following

Algorithm 1 Specification Generation

Input: Local dataset D with label space Y, model f, kernel function k, specification size n, iteration T .

Output: The class-wise RKME specification S.

• 1: for c ∈ Y do
• 2: Obtain the data Xc in D that is correctly classified by model f as class c. Initialize Zc by running k-means clustering on Xc with the number of clusters set to n.
• 3: for t = 1 to T do
• 4: Update β(t) c by using standard quadratic programming tools to minimize Eq. (1).
• 5: Update Z(t) c by optimizing Eq. (1) with the gradient descent method.
• 6: end for
• 7: end for
• 8: S ← {(β(T) c ,Z(T) c )}c∈Y .

Algorithm 2 Multiple Learnware Identification

Input: Learnwares {(fi, Si)}Ni=1 , user's local dataset Xu and {Xc}c∈Yu , constants M, K, λ.

Output: Identified models {fi}i∈I.

• 1: Based on the local dataset, the user generates specification Su by solving Eq. (1) and estimates class probabilities w by solving Eq. (2), then submits task requirements Ru = (Su,w) to the system.
• 2: Initialize I ← {}, I0 ← {} and U(I0,Ru) ← 0.
• 3: for t = 1 toM do
• 4: Obtain It by solving Eq. (4) with the successive shortest path algorithm applied to the minimum-cost maximum-flow formulation of U(It, Ru).
• 5: If U(It, Ru) > U(I, Ru) then I ← It; else exit loop.
• 6: end for
• 7: The system returns the helpful models {fi}i∈I .

problem via standard quadratic programming tools:

where ˆµ = 1 mu ∑mu i=1 k(xu,i, ·) is the empirical KME of Xu, and k is the kernel function from Eq. (1). The specification Su and the class probabilities w together form the user requirements Ru = (Su, w), which describe statistical properties of the user task without exposing raw data, laying the foundation for establishing the relations between the heterogeneous label spaces of learnwares and the user task.

Learnware Identification. After receiving the requirements, the system is required to identify a useful learnware combination for the user task. Let U(I, Ru) denote the utility of a set of learnwares {fi}i∈I to the user requirements Ru, and the learnware identification process can be formulated as

To quantify U(I , Ru), we first measure the class similarity via the class-wise specification. Let Si = {(βc1 ∈ ∆n ,Zc1 ∈ X n )}c1∈Yi and Su = {(βc2 ∈ ∆n ,Zc2 ∈ X n )}c2∈Yu denote the specifications for the i-th learnware and the user task.

The similarity between class c1 of the learnware and class c2 of the user task, denoted as sim(Si,c1 , Su,c2 ), is defined as:

where constant λ ensures non-negative similarity, and the latter term represents the Maximum Mean Discrepancy (MMD) between two RKMEs in RKHS Hk. According to Proposition 1, this term quantifies the difference between the conditional distributions of the two classes.

Based on the similarity, we quantify U(I, Ru) from a perspective of class matching, aiming to identify learnwares whose combined label space fully covers the task label space. Specifically, we construct a bipartite graph with learnware classes on the left and user task classes on the right. The edge weight between class c1 of learnware fi and user class c2 is wc2 · sim(Si,c1 , Su,c2 ), where wc2 is the estimated probability of class c2. Since each user class may have multiple similar learnware classes, we constrain that each user class can be matched by at most K learnware classes. Let variable e(i) c1,c2 indicate whether class c1 of learnware fi is matched to user class c2. Then, the quantification of U(I,Ru) is modeled as the following optimization problem:

To solve this optimization problem, we transform it into an equivalent minimum-cost maximum-flow problem by treating the constraints as edge capacities and the negated edge weights as costs, as shown in Figure 2. The minimum cost can then be determined using the successive shortest path algorithm [Edmonds and Karp, 1972]. By taking the negative of this value, we obtain the maximum weight matching, which corresponds to the utility U(I,Ru). Further details of this modeling are provided in Appendix B.

Even with U(I,Ru) quantified, the problem in Eq. (3) remains NP-hard. To solve it practically, we employ a greedy algorithm to iteratively optimize Eq. (3). Specifically, at the t-th iteration, It = It-1 ∪ {i} is obtained by solving:

The entire process of learnware identification is detailed in Algorithm 2, and its efficiency is analyzed in the following theorem, with the proof provided in Appendix C.

Theorem 1. Assume the maximum size of the learnware label spaces maxi∈[N] |Yi| ≤ Cf and the size of the user task label space |Yu| = Cu. The time complexity of our learnware identification method is O (NCf C 2u log (Cf + Cu)).

Since Cf and Cu are typically treated as constants, the time complexity of our method scales linearly with N, the dominant term. In contrast, the existing method [Wu et al., 2023] for identifying multiple homogeneous learnwares has a time complexity of Ω(N 2 ), highlighting the efficiency of ours. Several methods can further accelerate our identification process. For instance, in the optimization of Eq. (4), traversing all indices i ∈ [N] can be sped up via parallel computing. Additionally, techniques such as anchor learnwares [Zhou and Tan, 2024; Xie et al., 2023] and specification index [Liu et al., 2024] can substantially reduce the number of candidate learnwares N, further enhancing identification efficiency.

3.3 Reusing Learnware Combinations

10 While the identification phase seeks to provide learnwares whose combined label space covers the task label space, the reuse phase focuses on aligning and assembling these learnwares with the user task in a fine-grained manner. This assembly can be achieved by learning from the user's local labeled data, naturally excluding the need for learnware specifications during reuse and further protecting developer data privacy. Since effective reuse methods vary greatly with model structure, we design practical methods tailored for both nondeep and deep learning models, ensuring broad applicability.

Let {fi : X ↦→R|Yi| }i∈I be the identified learnwares with diverse label spaces. For non-deep learning models (e.g., linear and tree-based), we employ methods inspired by stacking [Wolpert, 1992] and classifier adaptation [Li et al., 2013]. Specifically, we augment the original features with logit vectors predicted by learnwares, which represent class probabilities. For instance, if X is the raw data and I = {1, 2}, the augmented data are X′ = [X, f1(X), f2(X)], and a simple secondary classifier (e.g. logistic regression) is then trained on X′ . For deep learning models, each learnware is finetuned by freezing all layers except the last. Then an average ensemble method [Zhou, 2025] is applied, which averages the outputs of all learnwares for final predictions.

These proposed methods are computationally efficient with few learnable parameters. Moreover, they remain effective and robust even with limited labeled data, and improve continuously with more instances, as validated in Section 4.

4 Experiments

In this section, we develop thousands of models with diverse label spaces, spanning 22 real-world tabular and image scenarios. We compare with existing methods and conduct ablation studies to validate the efficacy of our approach.

4.1 Experimental Setup

Here we introduce some common experimental setups.

Evaluation. For a scenario with C users, methods are evaluated by the average classification accuracy ∑Ci=1 Acci/C, where Acci is the accuracy on the i-th user's unlabeled instances, which are unseen by all learnwares in the system.

Contenders. We compare our approach with five methods: two baselines, Random and From-scratch, and three related methods, RKME-task [Wu et al., 2023], RKME-instance [Wu et al., 2023], and Linear-proxy [Guo et al., 2023]. Random randomly selects a learnware. From-scratch trains a new model from scratch with user labeled data and the same training algorithm as learnwares. RKME-task and RKME-instance identify single and multiple learnwares, respectively, using basic RKME specifications. Linear-proxy reduces the submitted model into a linear proxy model for identification. Since these contenders cannot simultaneously handle tabular and image scenarios across different label spaces, we enhance them with the reuse methods proposed in Section 3.3.

Configuration. We set the specification size n to 10 and use a Gaussian kernel k(x1, x2) = exp(-γ∥x1 -x2∥22 ) with γ = 0.1. For learnware search, K is chosen from {2, 3, 4} for different datasets, with constants M = 5 and λ = 100.

4.2 Evaluation on Tabular Scenarios

Scenario Construction. For tabular scenarios, we develop 745 learnwares, each with a unique label space, derived from 10 real-world datasets on the OpenML [Vanschoren et al., 2013] platform, spanning various domains such as healthcare, industrial, and biological fields. For each dataset, we select three classes from all classes, explore all possible combinations, and train models using LightGBM [Ke et al., 2017] on the corresponding training data. For instance, for a dataset with 10 classes, we generate (10 3 ) = 120 models. This means most classes in user tasks are unseen by any single learnware.

User Task Covering All Classes. For each dataset, we test user tasks covering all classes, with each task Du including the test set and 10 labeled data per class from the training set. Table 1 summarizes results from five repeats, showing that our method outperforms all contenders and significantly surpasses From-scratch, demonstrating the advantages of reusing identified learnwares with limited labeled data.

User Task Covering Partial Classes. We further test user tasks covering subsets of all classes. For a dataset with C classes, each task includes a subset of C - 1 or C - 2 classes from the test data. For example, the HAR dataset of 12 classes yields (12 11) + (12 10) = 78 tasks. Table 2 reports an 8/2 win/lose record, showing our method's efficacy even when the label spaces of user tasks and learnwares partially overlap.

User Task with Increasing Labeled Data. To further explore the benefits of our method, we test cases where labeled data per class increases from 10 to 5,000, or all available data if fewer than 5,000. Figure 3 shows that our method outperforms From-scratch with thousands of labeled data per class and even with all labeled data in some scenarios. This suggests that reusing identified learnwares could be more effective than training from scratch, even with sufficient data.

4.3 Evaluation on Image Scenarios

Scenario Construction. For image scenarios, we develop 300 heterogeneous learnwares from 12 real-world datasets: EuroSAT [Helber et al., 2019], SVHN [Netzer et al., 2011], CIFAR10/100 [Krizhevsky and Hinton, 2009], AID [Xia et al., 2017], Pets [Parkhi et al., 2012], Resisc45 [Cheng et al., 2017], DTD [Cimpoi et al., 2014], Food [Bossard et al., 2014], Caltech101 [Li et al., 2004], Flowers [Nilsback and Zisserman, 2008], and CUB2011 [Wah et al., 2011]. These datasets span diverse domains, including plants, animals, and objects. For each dataset, we randomly select 20% to 50% of all classes and develop learnwares using corresponding training data. We perform 25 random selections per dataset, training ResNet50 [He et al., 2016] models for 100 epochs using the SGD optimizer, with the initial learning rate chosen from {0.1, 0.01, 0.001} and cosine annealing learning rate decay.

For specification generation, we use image features extracted by a generic pre-trained model, consistent with prior learnware studies [Wu et al., 2023; Guo et al., 2023]. Specifically, we apply a ViT-L/32 [Dosovitskiy et al., 2021] model pre-trained on ImageNet [Russakovsky et al., 2015]. For comparison, we introduce the ViT-ImageNet method, which fine-tunes the pre-trained model's last layer with user labeled data, aligning with our reuse strategy. We also compare with other fine-tuning methods, including full parameter tuning and LoRA [Hu et al., 2022], detailed in Appendix D.

User Task Covering All Classes. Consistent with Section 4.2, we test user tasks covering all classes of the test set. Table 3 shows the superiority of our method across all scenarios, suggesting that identifying and reusing small proprietary models is more effective than training from scratch or finetuning a generic pre-trained model in few-shot settings.

User Task Covering Partial Classes. We further test tasks covering subsets of all classes. For each dataset, we randomly select 70% to 90% of all classes, with their test data as the user task. This process is repeated ten times to generate ten unique user tasks per dataset. Table 4 shows that our method consistently outperforms others, even when the user task label space completely differs from that of existing learnwares.

User Task with Increasing Labeled Data. Consistent with Section 4.2, we test cases with increasing labeled data per class. Figure 4 presents the superiority of our method in most scenarios, even when all labeled data are accessible.

4.4 Ablation Studies

Estimation of Class Probabilities. We compare our method using estimated probabilities w versus uniform probabilities on user tasks covering all classes. In class-balanced scenarios like CIFAR100 and Food, our method matches the accuracy of uniform probabilities. In class-imbalanced scenarios, it outperforms uniform probabilities by 6%, and in the most imbalanced scenario, Covertype, it leads by 45%. These results show the necessity of our class probability estimation.

Number of Identified Learnwares. We analyze how varying numbers of identified learnwares affect performance, as shown in Figure 5. Performance improves with more learnwares, but with diminishing returns. Reusing five learnwares generally yields satisfactory results, though cases like CTG, Otto-Product, and CIFAR100 could be further improved. In practice, the number of identified learnwares should depend on task complexity and available computational resources.

5 RelatedWork

Learnware. The learnware paradigm [Zhou, 2016; Zhou and Tan, 2024] proposes to build a large model platform comprising numerous high-performing models, enabling users to leverage existing models for their tasks. Each model is assigned a specification that characterizes its capabilities, allowing it to be identified for new tasks. Using the RKME specification, homogeneous learnwares can be identified by matching their data distributions with user tasks [Wu et al., 2023]. This specification is proven to scarcely contain any original data and possesses robust defense against common CIF.-100DTD Food CUB Resisc SVHN Euro. AID CIF.-10 Pets Flo. Caltech inference attacks [Lei et al., 2024]. To support effective identification from numerous learnwares, an anchor-based mechanism [Xie et al., 2023] enables efficient identification, and an evolvable learnware specification [Liu et al., 2024] continuously enhances learnware characterization and identification as the system scales. For heterogeneous feature spaces, algorithms for searching and reusing learnwares are developed by learning a unified specification space [Tan et al., 2023; Tan et al., 2024a]. Recently, the first learnware dock system, Beimingwu [Tan et al., 2024b], was released, providing implementations for the entire process of learnware paradigm.

Figure 5: Average accuracy (%) on user tasks covering all classes in tabular and image scenarios, with 10 labeled instances per class, as the number of identified learnwares varies among {1, 3, 5, 7, 9}.

For heterogeneous label spaces, prior work [Guo et al., 2023] focuses on identifying a single learnware and requires a powerful public feature extractor, limiting its applicability especially in tabular scenarios. In contrast, our work makes the first attempt to identify and reuse effective learnware combinations across different label spaces, enabling broader applications of learnwares beyond their original purposes.

Utilizing Given Source Task(s) or Model(s). Domain adaptation [Ben-David et al., 2006], transfer learning [Pan and Yang, 2010], and model reuse [Zhao et al., 2020] focus on solving target tasks using given source task(s) or model(s). Several studies also explore heterogeneous label spaces, including disjoint label space transfer learning [Luo et al., 2017], open set domain adaptation [Saito et al., 2018], and partial domain adaptation [Cao et al., 2019]. While these fields assume the given models are helpful for the target task or require access to raw source data, the learnware paradigm differs significantly, as it aims to identify and assemble useful models from numerous ones in a data-preserving way.

Model Pools. Model pools and hubs, like Hugging Face, have rapidly grown, hosting over a million models managed with only semantic descriptions. Some works, such as HuggingGPT [Shen et al., 2023] and ToolLLM [Qin et al., 2024], attempt to identify models or tools via these descriptions. However, since machine learning models are functions mapping inputs to outputs, statistical specifications in the learnware paradigm are essential for capturing their implicit capabilities and enabling effective identification and reuse beyond their original purposes. Some studies also focus on assessing the reusability or transferability of pre-trained models without fine-tuning [You et al., 2021; Ding et al., 2022; Zhang et al., 2023], but these often require running all models on user data without considering data privacy, which is impractical in real-world scenarios with numerous models.

6 Conclusion

This paper presents the first attempt to identify and assemble helpful learnware combinations for user tasks across different label spaces without leaking raw data. To achieve this, we characterize model capabilities across classes and establish relationships between diverse label spaces, proposing a practical identification and reuse method to solve user tasks involving previously unseen label spaces. Extensive empirical evaluations validate the effectiveness of our approach.

Acknowledgments

This research was supported by NSFC (62250069) and the Collaborative Innovation Center of Novel Software Technology and Industrialization. The authors would like to thank Jia-Wei Shan and Tian Qin for helpful discussions, and ZiChen Zhao for his participation in preliminary experiments. We are also grateful to the anonymous reviewers for their helpful comments.