acceptodds
Under review as a conference paper at ICLR 2027

ParaDa: Pretrained Parameters as Data for Federated Few-Shot Learning

Abstract

Large pretrained visual models provide a strong foundation for adapting recognition systems to new tasks with limited labeled data. However, in federated few-shot learning, target supervision remains scarce and is further fragmented across clients with heterogeneous observations, making reliable classifier construction difficult. Most existing approaches focus on using these limited target examples more effectively, while overlooking supervision that may already be encoded in the pretrained model itself. We introduce Parameters as Data (**ParaDa**), which treats pretrained classifier parameters as an additional source of supervision for new-task adaptation. For each source class, **ParaDa** pairs its text embedding with the corresponding pretrained classifier weight to train a reusable text-conditioned classifier weight predictor. The predictor produces classifier weights for target classes from their textual descriptions without revisiting source images, while available client examples provide task-specific refinement through their frozen visual features. In the federated setting, this design avoids repeated full-model training and requires only limited communication for classifier refinement. Experiments across diverse visual domains and few-shot protocols show that **ParaDa** achieves competitive recognition with few or no target labels and improves over competing methods on a range of tasks. It also substantially reduces task-specific computation and communication compared with full-model federated adaptation. Beyond the standalone framework, two simple, lightweight extensions use parameter-derived information to substantially enhance federated baselines in data-scarce settings, without complex auxiliary models or additional training stages. These results show that pretrained parameters can serve not only as model components, but also as supervision for data-scarce learning. Code available at [Anonymous GitHub](https://anonymous.4open.science/r/ParaDa-6FBF/README.md).

Primary area:
transfer learning, meta learning, and lifelong learning
Keywords:
Federated Learning, Few-Shot Learning, Transfer Learning, Parameter-Efficient Adaptation

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_VSTdOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes ParaDa (Parameters as Data), a method for federated few-shot learning that leverages pretrained classifier weights as an additional source of supervision. Specifically, the method trains a text-conditioned MLP to predict classifier weights from class embeddings, enabling classifier construction for new target classes without accessing source images. It further incorporates LLM-generated class descriptions for semantic refinement and learns classifier residuals from limited client data through federated aggregation. The resulting classifiers can also be used to initialize or regularize existing federated learning methods. Extensive experiments across diverse datasets, backbones, and few-shot settings demonstrate competitive classification performance with substantially reduced computation and communication costs compared to many federated baselines.

Critical strengths
  1. The paper introduces an interesting Parameters as Data perspective for federated few-shot learning, treating pretrained classifier weights as an additional source of supervision rather than merely as transferable model parameters. This provides a promising direction for addressing data scarcity in federated learning.
  2. The paper evaluates the proposed method across diverse datasets, model backbones, and few-shot settings, with comparisons against different federated learning baselines. The results demonstrate the effectiveness and practical potential of the proposed approach.
  3. The framework is simple and practical. By combining text-conditioned classifier construction with lightweight residual adaptation while keeping backbones frozen, it avoids expensive full-model updates during target adaptation and makes the weight predictor easy to reuse across tasks.
  4. The proposed method offers good efficiency and high modularity. Beyond low computation and communication costs, parameter-derived supervision can be easily plugged into existing federated learning pipelines via simple initialization or regularization.
Critical weaknesses
  1. ParaDa leverages a CLIP text encoder pretrained on large-scale image-text data, whereas most federated learning baselines do not have access to the same additional semantic knowledge. Although the visual backbones and target support budgets are same, the pretrained knowledge available to different methods is not fully controlled. This makes it difficult to determine whether the reported improvements stem from the proposed method or from the additional pretrained knowledge.
  2. The MLP predictor is trained on classifier weights from ImageNet-21K, while several downstream datasets exhibit substantial overlap with the source label space. Consequently, the predictor may benefit from previously observed class–weight relationships rather than demonstrating genuine generalization to unseen classes.
  3. The text-side refinement relies on LLM (such as GPT-4o) to generate class descriptions and VLM (such as CLIP) to extract semantic embeddings. These pretrained models already encode substantial semantic knowledge that may support strong zero-shot classification. It is therefore unclear to what extent the performance improvements can be attributed specifically to the proposed Parameters as Data mechanism, rather than to the powerful pretrained components.
Questions for authors
  1. Could the authors provide comparisons with baselines using the same pretrained semantic knowledge to ensure a fair evaluation?

  2. How does the source–target label overlap affect generalization? Could the authors evaluate the method after excluding overlapping classes from MLP training?

4 comments
AuthorsOpenReview ↗

Official Comment by Authors (1/2)

We sincerely thank the reviewer for the thoughtful and constructive comments and the time devoted to reviewing our manuscript. In the following, W denotes Weakness, Q denotes Question, and R denotes Reference.


W1&W3&Q1. ParaDa leverages a CLIP text encoder & Could the authors provide comparisons with baselines using the same pretrained semantic knowledge?

To address the reviewer's concern, we report the zero-shot performance and 5-shot linear probing results of CLIP models in Table 1. In addition, we include other CLIP-based baselines and [R2], which also leverages CLIP's semantic knowledge, to provide a more comprehensive comparison under the same pretrained semantic knowledge. For linear probing, we search over learning rates of {0.001, 0.003, 0.01}.

As shown, ParaDa achieves competitive performance with minimal additional overhead. From another perspective, our method effectively distills the knowledge encoded in pretrained models into a lightweight MLP, enabling efficient transfer of pretrained knowledge to downstream few-shot tasks. Its performance can be further improved as the coverage of pretrained models expands, as demonstrated by the additional experimental results presented in the sunsequent Table 2.

Table 1 Accuracy (%)CIFAR-100 (General)CUB (Fine-grained)EuroSAT (Remote)DTD (Texture)Waterbirds (Spurious)Avg.
[R1] (k=0)54.351.932.435.170.748.9
[R1] (k=5)69.178.280.861.071.372.1
CLIP zero-shot64.153.050.442.570.556.1
CLIP linear probing65.958.581.649.0667.964.6
FedTPG [R2]64.749.182.056.162.162.8
ParaDa68.280.882.662.671.173.1

AuthorsOpenReview ↗

Official Comment by Authors (2/2)

W2&Q2. Several downstream datasets exhibit substantial overlap with the source label space. How does the source–target label overlap affect generalization?

  • We provide a class-overlap analysis in 📍Sec. D.6, showing that ArtBench-10, Camelyon17, and OCT2017 have no class overlap with ImageNet-21K. We further evaluate the effect of removing overlapping classes from MLP training, averaging the results over five runs. The table below reports the accuracy differences before and after removing overlapping classes (Δ = Overlap-removed − Full training (%). Negative values indicate accuracy drops.).

    Δ (pp)CIFAR-10CIFAR-100Places365RESISC45EuroSATDTDArtBenchWaterbirdsAvg.
    K=0-0.57-1.65-4.98-1.32-0.94-1.35-0.87+1.10-1.32
    K=1-0.03-0.34-0.15-1.55-0.57-0.07-0.02-0.02-0.34

As shown, removing overlapping classes leads to only a modest decrease in accuracy, particularly in the one-shot setting, while the rankings relative to the baselines remain nearly unchanged.

  • We agree that our current method depends on the coverage of pretrained models. While this dependence is a limitation, it also offers an opportunity for extensibility: our framework can leverage classifier parameters from additional pretrained models to construct richer supervision.

    • we extend the ImageNet-21K pretrained ConvNeXt wAw_A by incorporating classifier weights wBw_B from another ConvNeXt pretrained on 📍EU-Common-707 (a European bird dataset) to construct the more (class text embedding, classifier parameter) pairs as data. Following the model-stitching approach of [R3], we align two frozen ConvNeXt encoders using public images by learning a linear mapping AA such that EA(x)≈AEB(x)E_A(x)\approx A E_B(x), then transform model B's classifier weights as w~B=A⊤wB\widetilde{w}_B=A^\top w_B. We combine the weights from both pretrained models to construct the training pairs and train the MLP using the same pipeline.

    • As shown in Table 2, this leads to improvements on CUB-2011 and Waterbirds, further addressing the reviewer's concern in W2.1 regarding performance on such datasets. We are conducting further experiments with pretrained parameters from different architectures and additional benchmarks for inclusion in the revision. Given the limited rebuttal period and academic computational resources, we currently report only the ConvNeXt results.

      Table 2 Accuracy (%)CIFAR-100CUBEuroSATDTDWaterbirdsAvg.
      K=0ImageNet-21K77.154.926.040.877.955.3
      K=0ImageNet-21K+ EU-Common-70778.2↑75.3↑26.1↑38.9⭣85.6↑60.8
      K=5ImageNet-21K82.586.687.871.290.983.8
      K=5ImageNet-21K+ EU-Common-70785.9↑88.4↑87.5⭣71.1⭣92.4↑85.1

From another perspective, our approach aim to distills the knowledge encoded in these pretrained parameters into a lightweight MLP with only 2.17M parameters. Clients only need to deploy this simple MLP to support a wide range of few-shot tasks, without requiring separate adaptation for each task.


Referece:\boldsymbol{\textbf{Referece:}}

[R1]: Image-Free Classifier Injection for Zero-Shot Classification, ICCV 2023.

[R2]: Federated Text-Driven Prompt Generation for Vision-Language Models. ICLR 2024.

[R3]: Revisiting Model Stitching to Compare Neural Representations. NeurIPS 2021.

Reviewer_VSTdOpenReview ↗

Official Comment by Reviewer VSTd

Thank you for the detailed responses. I will retain my positive score.

We sincerely thank you for your positive feedback and continued support of our work. We greatly appreciate your time and constructive comments, which have helped us improve our paper.

Reviewer_U4t4OpenReview ↗
Rating
2
Confidence
3
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

ParaDa trains an MLP that maps CLIP text embeddings of ImageNet-21K class names to the corresponding rows of a pretrained ViT-Tiny classifier. For each target class, GPT-4o writes three descriptions. These are mapped through the frozen MLP and averaged into a prior classifier, which is used directly when no labels are available. With a few labels, clients learn an additive residual on frozen features, and the server averages it over five rounds. The prior can also initialize or regularize the classifier of existing federated methods. Across 16 datasets, in full-way and 5-way settings, it leads most general and fine-grained benchmarks with ViT-Tiny, especially at one shot, and does so with far less communication than full-model baselines. It is less consistent on remote-sensing datasets.

Critical strengths
  1. A practical, low-cost pipeline. Encoders stay frozen, the weight predictor is reused across tasks, and only a classifier-sized residual is exchanged for five rounds. Without labels, no target-task communication is needed at all.

  2. Broad evaluation. The paper covers 16 datasets, including domains with little ImageNet-21K label overlap, two backbones, and both full-way and 5-way protocols. The prior also improves existing federated methods as a plug-in; for example, initialization improves SCAFFOLD by about 29 points on CIFAR-10 (Figure 7). The label-overlap audit (Table 21) is a welcome addition.

Critical weaknesses
  1. Limited novelty. Predicting classifier weights from class semantics without images is established (Elhoseiny et al., 2013; Changpinyo et al., 2016; Christensen et al., 2023), as is building classifiers from LLM-generated descriptions. The federated component is FedAvg on a linear residual over frozen features. The generated descriptions add only 1.5 to 3.9 points of macro accuracy over class names (Table 2).

  2. The comparisons do not isolate the contribution.

  • The advantage depends strongly on the backbone. With ConvNeXt, frozen-feature prototype baselines outperform ParaDa at one shot on all four fine-grained datasets, and the differences at five shots are small (Table 10).
  • The most natural comparisons are missing: CLIP zero-shot or linear probe, federated prompt learning (for example PromptFL (Guo et al., 2022) or FedTPG (Qiu et al., 2024)), image-free classifier injection, and a federated linear probe on the same frozen features.
  • Zero-shot accuracy is strongest where class names overlap heavily with ImageNet-21K (95% for CIFAR-100, 94% for Stanford Dogs), and weak on low-overlap domains such as EuroSAT, DTD, ArtBench and the medical sets.

References:

  • Elhoseiny et al., 2013: “Write a Classifier: Zero-Shot Learning Using Purely Textual Descriptions.” ICCV 2013.
  • Changpinyo et al., 2016: “Synthesized Classifiers for Zero-Shot Learning.” CVPR 2016.
  • Christensen et al., 2023: “Image-Free Classifier Injection for Zero-Shot Classification.” ICCV 2023.
  • Guo et al., 2022: “PromptFL: Let Federated Participants Cooperatively Learn Prompts Instead of Models — Federated Learning in Age of Foundation Model.” arXiv:2208.11625.
  • Qiu et al., 2024: “Federated Text-Driven Prompt Generation for Vision-Language Models.” ICLR 2024.
Questions for authors
  1. Under the same protocol, how does ParaDa compare with CLIP zero-shot and linear probe, federated prompt learning, image-free classifier injection, and a federated linear probe on frozen ViT-Tiny features?

  2. With ConvNeXt, frozen-feature prototype baselines outperform ParaDa at one shot on most general and fine-grained datasets. What explains this backbone dependence, and does the prior still help when the features already support prototype classifiers?

  3. If evaluation is restricted to target classes absent from the ImageNet-21K vocabulary, how do zero-shot accuracy and the one-shot advantage over baselines change?

2 comments
AuthorsOpenReview ↗

Official Comment by Authors (1/2)

We sincerely thank the reviewer for the thoughtful and constructive comments and the time devoted to reviewing our manuscript. In the following, W denotes Weakness, Q denotes Question, and R denotes Reference.


W1.1 Predicting classifier weights from class semantics without images is established.

  1. [R1 [R2] [R3] primarily focus on dataset-specific classifier expansion, whereas ParaDa emphasizes cross-task reusability in federated few-shot learning.

    • Prior works primarily study zero-shot classifier expansion within a given benchmark. For example, their main experiments on the CUB dataset construct classifiers from CUB's seen classes and predict weights for CUB's unseen classes.

    • In contrast, ParaDa directly treats the parameters of a ImageNet-21K pretrained model (and can even incorporate pretrained weights from other domains as data) as a large-scale supervision dataset constructed from (class text embedding, classifier weight) pairs, without requiring the design of additional class-level supervision structures. Once trained, this predictor is frozen and directly reused across 16 independent downstream datasets spanning diverse recognition domains, without retraining on their seen classes.

  2. ParaDa does not aim to design a complex classifier generator that only considers zero-shot learning.

    • Compared with the more elaborate architectures in [R1 [R2] [R3] designed for a single benchmark, we aim to establish an extensible pipeline that serves different downstream tasks in a unified manner. If these components are tightly coupled, it becomes difficult to independently evaluate the contribution of each module, and even harder to determine which components actually need to be changed when transferring to new scenarios. These methods also do not specifically consider few-shot learning scenarios, particularly in federated settings, where our approach leverages limited supervision to learn classifier parameters, which fundamentally differs from these zero-shot methods

    • We agree that the dual encoder-decoder architectures used in [R1] could replace our simple MLP, and that their multiple loss functions could replace our simple cosine loss, potentially leading to better performance. However, this would come at the cost of higher scaling and preprocessing overhead. These methods are designed for individual datasets, typically containing only hundreds of classes. Extending them to classifiers with a large-scale number of categories would incur substantial preprocessing costs. For instance, while manageable for benchmarks with hundreds of classes, scaling [R2] [R3] to ImageNet-21K with over 21K heterogeneous categories introduces substantial preprocessing overhead and additional challenges. We are currently unsure how to modify the design of [R2] [R3] to integrate it into our pipeline.

    • Nevertheless, we provide a variant of [R1] as a baseline that replaces our weight predictor ([R2] involves substantially more complex preprocessing, making its extension to ImageNet-21K nontrivial.). Specifically, considering that [R1] originally constructs classifiers from a single dataset's seen classes and predicts weights for its unseen classes, we modify its procedure to construct classifiers from the classes in ImageNet-21K and predict weights for classes in other downstream datasets. Other components, such as the dual encoder-decoder architecture and the combination of multiple loss functions, remain unchanged. Apart from this modification, we retain our residual-based design for few-shot adaptation. The detailed results are presented in the subsequent Table 1.


W2.2&Q1 compare with CLIP zero-shot and linear probe, federated prompt learning, image-free classifier injection.

To address the reviewer's concern, We report results for CLIP zero-shot classification and linear probing, federated prompt learning, and image-free classifier injection in Table 1. For linear probing, we search over learning rates of {0.001, 0.003, 0.01}. As shown, ParaDa achieves competitive performance with minimal additional overhead.

Table 1 Accuracy (%)CIFAR-100 (General)CUB (Fine-grained)EuroSAT (Remote)DTD (Texture)Waterbirds (Spurious)Avg.
[R1] (k=0)54.351.932.435.170.748.9
[R1] (k=5)69.178.280.861.071.372.1
CLIP zero-shot64.153.050.442.570.556.1
CLIP linear probing65.958.581.649.0667.964.6
FedTPG64.749.182.056.162.162.8
ParaDa68.280.882.662.671.173.1
AuthorsOpenReview ↗

Official Comment by Authors (2/2)


W2.1&Q2 With ConvNeXt, frozen-feature prototype baselines outperform ParaDa at one shot on most general and fine-grained datasets & What explains this backbone dependence.

We agree that our method currently performs better with Transformer architectures. One possible reason lies in how we construct the (class text embedding, classifier parameter) pairs. Specifically, the class text embeddings are obtained from a fixed CLIP text encoder, whereas the classifier parameters come from different architectures, such as ViT-Tiny (Transformer) or ConvNeXt (CNN). For CNN architectures, using a ResNet-based CLIP variant might provide better architectural compatibility. However, we intentionally use the same CLIP text encoder across all architectures to ensure a consistent experimental setting and highlight potential cross-architecture mismatches. Such mismatches may introduce representation misalignment, partly explaining the stronger performance of Transformer-based combinations (e.g., CLIP and ViT-Tiny). Nevertheless, cross-architecture combinations remain effective, and our approach retains its competitive performance and advantages over other baselines in terms of training and communication efficiency.


W2.3&Q3 If evaluation is restricted to target classes absent from the ImageNet-21K vocabulary, how do zero-shot accuracy and the one-shot advantage over baselines change?

  • We provide a class-overlap analysis in 📍Sec. D.6, showing that ArtBench-10, Camelyon17, and OCT2017 have no class overlap with ImageNet-21K. We further evaluate the effect of removing overlapping classes from MLP training, averaging the results over five runs. The table below reports the accuracy differences before and after removing overlapping classes (Δ = Overlap-removed − Full training (%). Negative values indicate accuracy drops.).

    ΔCIFAR-10CIFAR-100Places365RESISC45EuroSATDTDArtBenchWaterbirdsAvg.
    K=0-0.57-1.65-4.98-1.32-0.94-1.35-0.87+1.10-1.32
    K=1-0.03-0.34-0.15-1.55-0.57-0.07-0.02-0.02-0.34

As shown, removing overlapping classes leads to only a modest decrease in accuracy, particularly in the one-shot setting, while the rankings relative to the baselines remain nearly unchanged.

  • We agree that our current method depends on the coverage of pretrained models. However, this is also an inherent property of our framework: it can further leverage classifier parameters from additional pretrained models to construct richer supervision. Specifically,

    • we extend the ImageNet-21K pretrained ConvNeXt wAw_A by incorporating classifier weights wBw_B from another ConvNeXt pretrained on 📍EU-Common-707 (a European bird dataset) to construct the more (class text embedding, classifier parameter) pairs as data. Following the model-stitching approach of [R4], we align two frozen ConvNeXt encoders using public images by learning a linear mapping AA such that EA(x)≈AEB(x)E_A(x)\approx A E_B(x), then transform model B's classifier weights as w~B=A⊤wB\widetilde{w}_B=A^\top w_B. We combine the weights from both pretrained models to construct the training pairs and train the MLP using the same pipeline.

    • As shown in the following table 2, this leads to improvements on CUB-2011 and Waterbirds, further addressing the reviewer's concern in W2.1 regarding performance on such datasets. We are conducting further experiments with pretrained parameters from different architectures and additional benchmarks for inclusion in the revision. Given the limited rebuttal period and academic computational resources, we currently report only the ConvNeXt results. From another perspective, our approach aim to distills the knowledge encoded in these pretrained parameters into a lightweight MLP with only 2.17M parameters. Clients only need to deploy this simple MLP to support a wide range of few-shot tasks, without requiring separate adaptation for each task.

      Table 2 Accuracy (%)CIFAR-100CUBEuroSATDTDWaterbirdsAvg.
      K=0ImageNet-21K77.154.926.040.877.955.3
      K=0ImageNet-21K+EU-Common-70778.2↑75.3↑26.1↑38.9↓85.6↑60.8
      K=5ImageNet-21K82.586.687.871.290.983.8
      K=5ImageNet-21K+EU-Common-70785.9↑88.4↑87.5↓71.1↓92.4↑85.1

Referece:\boldsymbol{\textbf{Referece:}}

[R1]: Image-Free Classifier Injection for Zero-Shot Classification, ICCV 2023.

[R2]: Synthesized Classifiers for Zero-Shot Learning, CVPR 2016.

[R3]: Write a Classifier: Zero-Shot Learning Using Purely Textual Descriptions. ICCV 2013.

[R4]: Revisiting Model Stitching to Compare Neural Representations. NeurIPS 2021.

Reviewer_rEHKOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
3
Soundness
3
Read review
Paper summary

The paper frames its approach through a “Parameters as Data” perspective, treating pretrained classifier weights, paired with their corresponding class semantics, as reusable supervision for constructing classifiers for new target classes. It integrates several existing components—including text-conditioned classifier-weight synthesis, LLM-generated class descriptions, and lightweight federated residual adaptation—into the federated few-shot learning setting.

Critical strengths
  1. The paper is clearly structured with a coherent storyline and informative visualizations, which effectively communicate the rationale behind the design and the proposed framework.
  2. Extensive experiments across diverse datasets and test settings validate the strong empirical performance of the method, with consistent gains on both recognition accuracy and communication efficiency.
Critical weaknesses
  1. The novelty does not lie in the individual components themselves, but rather in integrating them into the federated learning setting. However, this contribution remains relatively limited, as the overall framework largely combines existing techniques without introducing a fundamentally new learning mechanism. Its core idea of learning a mapping from class semantics to visual classifier weights has been investigated in prior studies on semantic classifier synthesis.

  2. In particular, Changpinyo et al. developed synthetic classifiers for zero-shot recognition; Christensen et al. proposed ICIS, which builds classifiers from semantic descriptors and pretrained classifier weights without source images; Lyu et al. leveraged LLM-generated multi-view descriptions to inject classifier weights for unseen classes. Accordingly, the “parameters as data” formulation does not represent a fundamentally novel classifier synthesis paradigm.

  3. The experimental evaluation lacks comparisons with the most closely related methods, particularly ICIS and CEMIL. Although these methods were not originally designed for federated learning, they could be adapted to the same backbone, target datasets, and federated residual-adaptation protocol. Such controlled comparisons are necessary to determine whether the reported improvements arise from the proposed “Parameters as Data” formulation, the LLM-generated descriptions, or the federated adaptation procedure.

ICIS: Image-Free Classifier Injection for Zero-Shot Classification, ICCV 2023. Paper CEMIL: Expanding the Category of Classifiers with LLM Supervision, IJCAI 2025.

Questions for authors

See weakness

4 comments
AuthorsOpenReview ↗

Official Comment by Authors (1/2)

We sincerely thank the reviewer for the thoughtful and constructive comments and the time devoted to reviewing our manuscript. In the following, W denotes Weakness, Q denotes Question, and R denotes Reference.


W1. Core idea of learning a mapping from class semantics to visual classifier weights has been investigated.

W2. Formulation does not represent a fundamentally novel classifier synthesis paradigm.

W3. The experimental evaluation lacks comparisons with [R1] and [R2].

We thank the reviewer for highlighting the related work on semantic classifier synthesis. We would like to clarify the following:

  1. [R1] and [R2] primarily focus on dataset-specific classifier expansion, whereas ParaDa emphasizes cross-task reusability in federated few-shot learning.

    • Prior works such as [R1] and [R2] primarily study zero-shot classifier expansion within a given benchmark. For example, their main experiments on the CUB dataset construct classifiers from CUB's seen classes and predict weights for CUB's unseen classes.

    • In contrast, ParaDa directly treats the classifier parameters of a general-purpose ImageNet-21K pretrained model (and can even incorporate pretrained weights from other domains as data) as a large-scale supervision dataset constructed from (class text embedding, classifier parameter) pairs, without requiring the design of additional class-level supervision structures. Once trained, this predictor is frozen and directly reused across 16 independent downstream datasets spanning diverse recognition domains, without retraining on their seen classes.

  2. ParaDa does not aim to design a complex classifier generator that only considers zero-shot learning.

    • Compared with the more elaborate architectures in [R1] and [R2] designed for a single benchmark, we aim to establish an extensible pipeline that serves different downstream tasks in a unified manner. If these components are tightly coupled, it becomes difficult to independently evaluate the contribution of each module, and even harder to determine which components actually need to be changed when transferring to new scenarios. Importantly, the modular design allows more sophisticated classifier generators or adaptation strategies to be incorporated independently. These methods also do not explicitly consider few-shot learning scenarios, particularly in federated settings, where our approach leverages limited supervision to learn classifier parameters.

    • We agree that the dual encoder-decoder architectures used in [R1] and [R2] could replace our simple MLP, and that their multiple loss functions could replace our simple cosine loss, potentially leading to better performance. However, this would come at the cost of higher scaling and preprocessing overhead. These methods are designed for individual datasets, typically containing only hundreds of classes. Extending them to classifiers with a large-scale number of categories would incur substantial preprocessing costs. For instance, while manageable for benchmarks with hundreds of classes, scaling [R2] to ImageNet-21K with over 21K heterogeneous categories introduces substantial preprocessing overhead and additional challenges.

    • Nevertheless, we provide a variant of [R1] as a baseline that replaces our weight predictor ([R2] involves substantially more complex preprocessing, making its extension to ImageNet-21K nontrivial.). Specifically, considering that [R1] originally constructs classifiers from a single dataset's seen classes and predicts weights for its unseen classes, we modify its procedure to construct classifiers from the classes in ImageNet-21K and predict weights for classes in other downstream datasets. Other components, such as the dual encoder-decoder architecture and the combination of multiple loss functions, remain unchanged. Apart from this modification, we retain our residual-based design for few-shot adaptation. The detailed results are as follows:

AuthorsOpenReview ↗

Official Comment by Authors (2/2)

5-shot Accuracy (%)CIFAR-100 (General)CUB (Fine-grained)EuroSAT (Remote)DTD (Texture)Waterbirds (Spurious)OCT2017 (Medical)Avg.
[R1] (k=0)54.351.932.435.170.740.947.6
[R1] (k=5)69.178.280.861.071.379.073.2
ParaDa68.280.882.662.671.178.774.0

As shown, the dual encoder-decoder trained in [R1] can directly replace our MLP for weight prediction and slightly outperform our method in some scenarios, suggesting its potential as an alternative. However, these improvements are not consistent. Therefore, directly adopting such methods would still require extensive ablation studies on the loss functions and architectural designs, which are beyond the scope of this paper. We believe that further exploring these designs as alternatives to our MLP and cosine loss within our framework is an interesting direction for future work.


Refereces:\boldsymbol{\textbf{Refereces:}}

[R1]: Image-Free Classifier Injection for Zero-Shot Classification, ICCV 2023.

[R2]: Expanding the Category of Classifiers with LLM Supervision, IJCAI 2025.

I thank the authors for the detailed response and the additional ICIS comparison. In my view, the contribution primarily extends the applicability of an existing idea rather than introduces a new learning method. While I appreciate the paper’s clear presentation, these strengths do not fully resolve my main concern. I maintain my original score.

We sincerely thank the reviewer for their continued feedback and thoughtful consideration of our work.

We would like to further emphasize that our primary contribution lies in establishing a practical and generalizable learning pipeline that leverages pretrained parameters as supervision for federated few-shot learning. This enables effective adaptation with extremely limited target data, substantially reduced computation and communication, and seamless integration with existing federated learning methods.

While we acknowledge that some underlying components have been explored in prior work, we sincerely hope that the methodological contribution of our framework can also be appreciated in terms of the new learning capabilities and practical benefits it enables, beyond the novelty of its individual components.

We sincerely appreciate the reviewer's time and constructive feedback throughout the discussion. We hope that our clarifications and additional experimental evidence will receive consideration in the final assessment.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.