- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper proposes TransLP++, a transductive extension of LP++ for few-shot CLIP adaptation. The classifier keeps the LP++ parameterization (a visual prototype plus a learnable scaled text embedding ) and is optimized with an objective that combines (i) label-smoothed cross-entropy on the support set, (ii) a mutual-information term over the unlabeled query set, and (iii) a KL regularizer toward CLIP's zero-shot predictions. Auxiliary assignment variables are introduced to relax the objective, leading to an alternating scheme: an approximate closed-form update for and block-coordinate updates of with step sizes derived from block-wise Lipschitz constants; in practice a momentum variant with a fixed learning rate is used. Experiments on 11 datasets, 5 CLIP backbones and 1–16 shots show consistent improvements over LP++, TransCLIP and TIM++.
Critical strengths
- The motivation is clear (LP++ is inductive and discards query-set information, which matters most in the low-shot regime), and the method follows directly from it.
- The experimental coverage is broad: 11 datasets × 5 backbones × 5 shot settings × 3 seeds, with standard deviations, a sensitivity analysis (Table 7), an ablation of the two query-related terms (Table 3) and an optimizer comparison (Tables 5–6). Gains over TIM++ are consistent across all 25 backbone–shot combinations, and the largest gains appear at 1–2 shots, as the motivation predicts.
- A single hyperparameter configuration is used for all datasets, backbones and shots, which is good practice. Anonymous code is provided.
- The writing is clear and the derivations are given in full in the appendix.
Critical weaknesses
-
Limited novelty with respect to TIM++ and LP++. Eq. (2) is the TIM/TIM++ objective (support CE + query mutual information + KL to zero-shot predictions) combined with the LP++ logit parameterization and label smoothing. The relaxation with auxiliary variables (Prop. 1), the KKT update (Prop. 2), the block Lipschitz constants (Prop. 3) and the centroid initialization (Prop. 4) all closely follow the TIM/TIM++ and LP++ derivations. The ablation in Table 3 attributes almost all of the gain to the query-MI term (+14.72 / +5.07 / +0.98), which is TIM++'s contribution, while the KL term alone is marginal or negative at 16 shots. The paper should state precisely what is new beyond "TIM++ objective + LP++ classifier", and add an ablation that isolates the term (e.g., TransLP++ with fixed to 0 vs. TIM++ under identical optimization).
-
The theory is not what is evaluated. The Lipschitz step sizes of Prop. 3 are presented as a main contribution, but every main result uses the momentum variant with a fixed lr = 1e-3 and a per-step normalization of each , which the analysis does not cover. Convergence of the full alternating scheme (including the -update) is not established; citing Theorem 2.2 of LP++ only covers the sub-problem with fixed. The approximation in Eq. (6), which treats the per-sample normalization constant as sample-independent, is not analyzed or empirically validated (e.g., by reporting the objective value under the exact vs. approximate update).
-
Computational cost relative to the closest competitor is underplayed. Table 4 shows TIM++ at ~2.28 s and TransLP++ at ~118 s on ImageNet-16shot (roughly 50×), for an average gain of 1.2–1.6 points. The text compares the runtime to LP++ (113 s) rather than to TIM++. Please explain why inner iterations are necessary when TIM++ converges in a few seconds, and report accuracy-vs-time curves.
-
Missing comparisons. LIMO [1] is cited as a related transductive few-shot CLIP method but is not compared. Standard few-shot CLIP baselines used in the LP++ paper (e.g., CoOp, Tip-Adapter-F, PromptSRC) are absent from Table 1. In addition, the query set is the full test set ( on ImageNet); results with smaller or batched query sets and under class imbalance, as analyzed in TransCLIP, are needed to assess the robustness of the transductive setting.
-
Hyperparameter selection and consistency. Section 4.1 states that hyperparameters were chosen on "validation performance" under the 4-shot setting; since the method is transductive on the test set, please confirm that a held-out validation split was used and that the query set at tuning time was not the test set. Table 7 also shows outperforming the chosen at all three shot settings (76.13 vs. 75.88, 79.04 vs. 78.73, 82.17 vs. 82.01) and larger helping at 4/16 shots, which is inconsistent with the stated selection procedure.
-
Per-dataset failures are not discussed. On Caltech101 all transductive methods, including TransLP++, fall below zero-shot CLIP at 1–2 shots (89.71 vs. 93.31) and below LP++ at every shot; on ImageNet TransLP++ trails LP++ and TIM++ at 1–8 shots. An analysis of when transduction hurts (e.g., when the zero-shot prior is already strong) would make the contribution more informative.
-
Presentation issues. Zanella et al. 2024a and 2024b are the same paper (duplicate reference); "Appendix 1" in Section 3.3 should be Algorithm 1; a stray closing quotation mark ends Appendix C.2; "Notablly" in A.3; Lemma 2 defers its proof to LP++ without restating it; Eq. (12) says the initializers are normalized so that cancel, yet Algorithm 1 (lines 4–5) still carries factors; the choice (vs. the stated bound ) is not justified.
Overall, this is a carefully executed and well-evaluated engineering combination of two existing methods. However, the technical contribution over TIM++/LP++ is thin, and the theoretical component is not used in the reported system. If the authors can (a) isolate the contribution of the LP++ parameterization against TIM++, (b) justify or reduce the 50× cost relative to TIM++, and (c) add LIMO and the standard few-shot CLIP baselines together with a query-set-size analysis, I would consider raising my score.
[1] Baklouti et al., Language-aware information maximization for transductive few-shot CLIP, TMLR 2026.
Questions for authors
See above
6 comments
Response 2: Justify the computation cost relative to TIM++
We thank the reviewer for this question. The computational overhead of TransLP++ compared with TIM++ is real, and we report this difference transparently. The gap mainly arises from their different classifier parameterizations and optimization procedures. Although TIM++ and TransLP++ minimize the same family of losses (support cross-entropy, query-set mutual information, and CLIP-guided KL regularization), their optimization subproblems differ substantially. TIM++ uses a negative squared-distance prototype classifier () and optimizes only the prototype matrix . With the auxiliary-variable reformulation, both the -update and the -update admit closed-form solutions.
In contrast, TransLP++ adopts the more expressive LP++ parameterization, , and jointly optimizes the classifier weights and class-specific text coefficients . Due to the coupling introduced by the shared softmax, these subproblems do not admit closed-form solutions. We therefore employ block-coordinate Majorize-Minimize optimization, requiring multiple inner gradient updates with block-wise Lipschitz step sizes. Specifically, the Momentum variant uses 1000 outer iterations with 20 inner updates per iteration, resulting in approximately 20000 effective update steps, whereas TIM++ uses 150 outer iterations with closed-form updates. This difference is the primary source of the runtime gap.
Overall, the additional computation reflects a trade-off between optimization efficiency and classifier expressiveness. TIM++ benefits from closed-form prototype updates, whereas TransLP++ adopts a more flexible multimodal classifier that explicitly incorporates CLIP's text prior, leading to consistent accuracy improvements over TIM++ across the evaluated backbone-shot settings. Our additional experiments in the following table show that TransLP++ with 200 iterations already outperforms TIM++ across all five shot settings, with a runtime of 27.70 s on ImageNet, while the default 1,000-iteration setting further improves accuracy to achieve the best results (118 s). These results demonstrate the flexibility to balance computational cost and performance by adjusting the number of iterations. We will incorporate this analysis into the Computational Efficiency subsection to clarify the sources of the overhead and the trade-off between computational cost and performance.
| Method | Outer Iterations | 1-shot | 2-shot | 4-shot | 8-shot | 16-shot | Runtimex(ImageNet, 16-shot) |
|---|---|---|---|---|---|---|---|
| TIM++ | 150 steps | 74.32 ± 0.61 | 75.70 ± 0.64 | 77.46 ± 0.72 | 79.02 ± 0.48 | 80.85 ± 0.34 | 2.28s |
| TransLP++ | 100 steps | 73.56 ± 0.76 | 75.58 ± 0.73 | 77.68 ± 0.64 | 79.32 ± 0.43 | 80.87 ± 0.29 | 13.78s |
| TransLP++ | 200 steps | 74.70 ± 0.82 | 76.31 ± 0.75 | 78.22 ± 0.56 | 79.85 ± 0.44 | 81.60 ± 0.29 | 27.70s |
| TransLP++ | 300 steps | 75.20 ± 0.80 | 76.62 ± 0.75 | 78.47 ± 0.52 | 80.08 ± 0.46 | 81.83 ± 0.32 | 41.73s |
| TransLP++ | 1000 steps | 75.88 ± 0.59 | 77.25 ± 0.53 | 78.73 ± 0.55 | 80.36 ± 0.44 | 82.01 ± 0.35 | ~118s |
Response 3: Additional Baselines
We thank the reviewer for this valuable suggestion. We agree that LIMO is a strong method. However, our work focuses on black-box adaptation, where the pretrained encoders remain frozen, and adaptation is performed using their extracted features without accessing or modifying the internal architecture or parameters of the pretrained VLMs. LIMO introduces trainable LoRA modules into the query, key, and value (QKV) projections of CLIP's vision and text encoders, thus requiring access to and modification of the pretrained VLM's internal architecture. In contrast, the proposed TransLP++ and the baselines considered in our paper perform adaptation exclusively at the feature and classifier levels, without modifying the pretrained CLIP encoders. This black-box setting offers broader applicability, particularly when access to the internal architecture or parameters of pretrained VLMs is restricted.
To make our comparison more comprehensive, we additionally include several representative few-shot black-box adaptation methods, including TF, BD-CSPN, LaplacianShot, PT-MAP, TIM, and Tip-Adapter-F. These methods complement the existing comparisons with LP, LP++, TransCLIP, and TIM++. As shown in the updated table, TransLP++ achieves the best performance across all five shot settings, consistently outperforming the other methods. We will incorporate these additional results and explicitly clarify the baseline selection criteria in the revised manuscript.
| Method | 1-shot | 2-shot | 4-shot | 8-shot | 16-shot |
|---|---|---|---|---|---|
| TF (Arxiv'19) | 43.50 ± 2.13 | 56.99 ± 1.68 | 65.22 ± 0.84 | 70.70 ± 0.75 | 73.74 ± 0.57 |
| BD-CSPN (ICCV'20) | 51.02 ± 1.83 | 61.86 ± 1.69 | 67.01 ± 1.23 | 70.81 ± 0.89 | 73.59 ± 0.65 |
| LaplacianShot (ICML'20) | 51.53 ± 2.21 | 62.63 ± 1.28 | 67.45 ± 1.24 | 70.50 ± 0.71 | 72.94 ± 0.49 |
| PT-MAP (ICANN'21) | 53.02 ± 2.23 | 62.39 ± 1.64 | 66.12 ± 0.56 | 68.70 ± 0.43 | 70.53 ± 0.45 |
| TIM (NeurIPS'20) | 55.07 ± 2.83 | 64.82 ± 1.85 | 71.02 ± 1.72 | 75.17 ± 1.34 | 78.15 ± 1.22 |
| LP (ICML'21) | 45.35 ± 1.44 | 56.57 ± 1.06 | 66.18 ± 1.40 | 73.36 ± 0.48 | 78.23 ± 0.46 |
| Tip-Adapter-F (ECCV'22) | 71.38 ± 0.64 | 73.80 ± 0.66 | 76.13 ± 0.50 | 78.55 ± 0.64 | 81.32 ± 0.48 |
| LP++ (CVPR'24) | 70.27 ± 0.48 | 72.83 ± 0.89 | 75.62 ± 0.84 | 77.94 ± 0.63 | 80.27 ± 0.38 |
| TransCLIP (NeurIPS'24) | 73.01 ± 1.39 | 74.32 ± 1.13 | 75.96 ± 0.68 | 77.30 ± 0.65 | 78.32 ± 0.66 |
| TIM++ (AAAI'26) | 74.32 ± 0.61 | 75.70 ± 0.64 | 77.46 ± 0.72 | 79.02 ± 0.48 | 80.85 ± 0.34 |
| TransLP++ (Ours) | 75.88 ± 0.59 | 77.25 ± 0.53 | 78.73 ± 0.55 | 80.36 ± 0.44 | 82.01 ± 0.35 |
~~
Response 4: Effect of query-set size
We thank the reviewer for this constructive question. To investigate the effect of query-set size, we conduct experiments on all 11 benchmark datasets with the support set fixed. We consider 15, 100, 500, and 1,000 query samples, as well as the entire query set. For each limited query-set size, we randomly sample 100 times and report the mean accuracy and standard deviation across trials. Results using the entire query set are averaged over three random seeds. As shown in the following table, TransLP++ consistently outperforms TIM++ across all query-set sizes and shot settings. Its performance generally improves as more query samples become available, while the standard deviations tend to decrease. Notably, TransLP++ maintains relatively stable performance even with only 15 query samples, whereas TIM++ suffers substantial degradation in several settings. These results demonstrate the effectiveness and robustness of TransLP++ under varying query-set sizes.
| Query Size | Method | 1-shot | 2-shot | 4-shot | 8-shot | 16-shot |
|---|---|---|---|---|---|---|
| 15 | TIM++ | 59.47 ± 14.75 | 61.07 ± 13.13 | 42.95 ± 17.02 | 25.38 ± 14.11 | 22.51 ± 14.91 |
| 15 | TransLP++ | 63.44 ± 11.31 | 63.79 ± 11.34 | 64.25 ± 11.23 | 64.85 ± 11.33 | 65.25 ± 11.30 |
| 100 | TIM++ | 62.60 ± 7.03 | 61.12 ± 8.46 | 50.56 ± 6.59 | 49.17 ± 5.87 | 52.12 ± 8.03 |
| 100 | TransLP++ | 65.68 ± 4.57 | 66.85 ± 4.53 | 67.91 ± 4.35 | 68.92 ± 4.38 | 69.66 ± 4.17 |
| 500 | TIM++ | 68.99 ± 2.57 | 65.74 ± 3.66 | 66.76 ± 1.79 | 68.54 ± 1.73 | 70.17 ± 1.67 |
| 500 | TransLP++ | 71.48 ± 2.34 | 73.22 ± 2.04 | 74.89 ± 1.86 | 76.36 ± 1.79 | 77.66 ± 1.73 |
| 1,000 | TIM++ | 70.61 ± 1.79 | 71.99 ± 1.58 | 71.92 ± 3.73 | 70.90 ± 2.56 | 75.44 ± 3.51 |
| 1,000 | TransLP++ | 73.14 ± 1.85 | 74.98 ± 1.57 | 76.69 ± 1.36 | 78.25 ± 1.26 | 79.73 ± 1.17 |
| All | TIM++ | 74.32 ± 0.61 | 75.70 ± 0.64 | 77.46 ± 0.72 | 79.02 ± 0.48 | 80.85 ± 0.34 |
| All | TransLP++ | 75.88 ± 0.59 | 77.25 ± 0.53 | 78.73 ± 0.55 | 80.36 ± 0.44 | 82.01 ± 0.35 |
We sincerely thank the reviewer for the positive assessment of our work, particularly for recognizing the clear motivation, comprehensive experimental evaluation, consistent improvements over TIM++, the unified hyperparameter configuration across all experiments, and the clarity of the manuscript and theoretical derivations. We also appreciate the reviewer’s constructive questions and suggestions, which help us further clarify and strengthen our work. We address these concerns one by one below.
Response 1: Contribution of the TransLP++ parameterization over TIM++
We thank the reviewer for this constructive feedback, which motivated us to further investigate the factors contributing to TransLP++'s performance gains over the state-of-the-art method TIM++. In addition to the ablation studies on different information sources in TransLP++ (Table 3), we conduct further experiments to examine two key differences between TransLP++ and TIM++: (1) the classification logits and (2) label smoothing. As shown in the following table, simply replacing TIM++'s distance-based logits with visual similarity logits fi⊤wk does not consistently improve performance. It slightly degrades accuracy in low-shot settings while yielding gains in higher-shot settings. In contrast, incorporating the CLIP text prior through fi⊤(wk+αktk) consistently and substantially improves performance across all shot settings. Label smoothing provides additional but relatively modest gains. These results indicate that incorporating CLIP's text prior into the classifier logits is the primary contributor to TransLP++'s performance improvement over TIM++.
A straightforward way to also incorporate the text prior into TIM++ would be to add a text-distance term to the classifier logits, namely, −2τ∣fi−wk∣2−2β∣fi−tk∣2. However, cross-modal semantic alignment in CLIP does not necessarily imply small Euclidean distances between visual and textual embeddings. Thus, directly introducing a text-distance term may not effectively capture their semantic correspondence. This suggests that incorporating CLIP's text prior into the prediction function of TIM++ is not as straightforward as simply extending its original distance-based formulation.
We thank the reviewer for this constructive feedback and will clarify these analysis in the revised manuscript.