Pith. sign in

REVIEW 4 major objections 6 minor 27 references

Instruction Learning Paradigms: A Dual Perspective on White-box and Black-box LLMs

T0 review · 4 major / 6 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read This paper claims that fusing black-box initialization with white-box hidden and output representations produces better LLM instructions than prior prompt optimization methods, reaching a mean score of 0.6955 across 30 tasks.

desk verdict A plausible incremental extension of InstructZero/INSTINCT whose own per-task table contradicts its 'consistently outperforms' claim; the mean gain is real but small and not statistically supported. read the letter →

arxiv 2506.21573 v1 pith:X4CID4ZG submitted 2025-06-14 cs.CL cs.AIcs.LG

Yanwei Ren , Liu Liu , Baosheng Yu , Jiayan Qiu , Quan Chen This is my paper
classification cs.CLcs.AIcs.LG
keywords instructionoptimizationpromptengineeringblack-boxLLMwhite-boxhiddenrepresentationscosinesimilarityregularizationsoftsearchlearning
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper tries to establish that instruction optimization for large language models is best done by a hybrid: let a strong black-box model generate the initial pool of candidate instructions, then use a smaller white-box model's internal representations - hidden states plus the embedding of the black-box output - to train a predictor that iteratively refines those instructions. If the claim holds, practitioners can get better instructions than pure black-box search methods while avoiding the full cost of white-box fine-tuning. The reported evidence is a mean score of 0.6955 across 30 instruction-following tasks, surpassing InstructZero (0.6733) and EvoPrompt (0.6800), with ablations showing each component contributes. The reason to care is that instruction quality is a bottleneck for LLM performance across reasoning, translation, and classification tasks, and this offers a cheaper route to better prompts.

What carries the argument

The load-bearing objects are (1) the fused representation $c_{ho} = \operatorname{AvgPool}([h; o])$, where $h$ is the white-box hidden state of the instruction and $o$ is the white-box embedding of the black-box model's output; and (2) the loss $\mathcal{L} = \mathcal{L}_{\mathrm{Reg}} + \lambda \mathcal{L}_{\mathrm{Sim}}$, with $\mathcal{L}_{\mathrm{Sim}}$ enforcing $\sigma(\hat{s}_i) \approx \sigma(\tilde{s}_i)$ for $\tilde{s}_i$ the cosine similarity between the $i$-th instruction embedding and the best instruction embedding. The dynamic weight $\lambda = \max(a, \min(b, \mathcal{L}_{\mathrm{Reg}}))$ lets the regularizer's influence scale with the regression error. This mechanism trains the neural network to predict scores while keeping candidate instructions semantically aligned with the best one found so far.

What would settle it

Run the optimization loop on the same 30 tasks but replace the cosine-similarity target in $\mathcal{L}_{\mathrm{Sim}}$ with a random fixed embedding or with the worst-performing instruction embedding. If the mean score stays near 0.6955, the regularizer's specific target is not what drives the gain; if it collapses below the InstructZero baseline, the similarity signal is genuinely load-bearing.

Watch

Extended reading notes

Core claim

The paper's central claim is that instruction optimization improves when a strong black-box model supplies the initial instruction pool and a white-box model's internal representations - hidden states from intermediate layers plus output features produced by running the black-box output through the white-box model - are fused and used to train a score predictor. With ChatGPT-4o initialization, Vicuna-13B features, and a cosine-similarity regularizer that pulls each instruction embedding toward the current best instruction embedding, the framework reaches a mean score of 0.6955 over 30 tasks, ahead of InstructZero (0.6733), EvoPrompt (0.6800), APE (0.6207), and Instinct (0.6113). Ablation results attribute part of the gain to the fused output representation, part to the similarity regularizer, and part to the choice of ChatGPT-4o as initializer.

Load-bearing premise

The method assumes that cosine similarity to the current best instruction's fused embedding is a trustworthy proxy for instruction quality, so that pushing new instructions toward that embedding improves scores rather than merely copying it.

Editorial extensions

If this is right

  • If the central claim holds, instruction optimization no longer needs to choose between white-box and black-box access; the hybrid path yields better instructions than either alone.
  • The gain is concentrated in reasoning-heavy tasks like cause_and_effect (0.9467 vs. 0.8000 for ChatGPT-4o initialization) and word sorting (0.5867 vs. 0.3267 for Instinct), suggesting internal representations carry task-specific signal.
  • Removing the similarity regularizer drops the mean from 0.6955 to 0.6840, so the regularizer contributes a measurable but modest part of the advantage; removing output representation drops it to 0.6717.
  • The method works with different black-box initializers (ChatGPT 3.5/4/4o, DeepSeek V3), with ChatGPT-4o best at 0.6713 before refinement, so the refinement step adds beyond the initializer's strength.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The cosine-similarity regularizer is self-referential (target is the current best instruction), which risks reinforcing the current best rather than exploring; a natural extension would be to compare against a diverse set of top instructions or a learned centroid.
  • The 0.0115 mean gain from the similarity regularizer is small relative to seed variability, and the per-task plots in the appendix show it helps some tasks and hurts others, so the aggregated claim may hide task-level trade-offs.
  • The paper excludes two datasets from InstructZero's original 32; re-running on the full set would clarify whether the benchmark selection affects the reported ordering of methods.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 6 minor

Summary. This manuscript proposes an instruction-learning framework that initializes candidate instructions with a black-box LLM (ChatGPT-4o), represents them using a white-box model's hidden and output features (Vicuna-13B), and trains an MLP score predictor with a regression loss and a cosine-similarity regularizer anchored on the current best instruction. The optimizer iteratively refines instructions over 100 iterations, and the authors report a mean score of 0.6955 across 30 tasks, compared to 0.6733 for InstructZero and 0.6800 for EvoPrompt. The paper claims that the method consistently outperforms state-of-the-art baselines.

Significance. If the reported gains were statistically robust and the optimization loop were fully specified, the hybrid black-box/white-box scheme would be a useful contribution to automated prompt optimization. The paper provides a broad 30-task benchmark, ablations of initialization models, output representation, and similarity regularization, and a table of best-performing instructions. However, the central claim is currently supported only by a small mean gap without significance testing, the method's core generation step is not described, and the similarity regularizer is self-referential and unvalidated. The contribution is therefore not yet established.

major comments (4)
  1. [§4.3, Table 1] The statement that the method 'consistently outperforms' all baselines is contradicted by the paper's own Table 1: compared with InstructZero the method is worse on 15 of 30 tasks (e.g., antonyms 0.7533 vs 0.8270, rhymes 0.6667 vs 1.0000, sentence_similarity 0.0000 vs 0.2830) and better on 13, with 2 ties; compared with EvoPrompt it is worse on 17 tasks and better on 11. The reported mean advantage (0.6955 vs 0.6733 and 0.6800) is therefore an average improvement, not consistent outperformance, and the abstract and Section 4.3 should be revised accordingly.
  2. [§4.3, Figure 2] No measure of uncertainty is provided for the central result. Table 1 contains only point estimates, and Figure 2 reports distributions for three seeds of the proposed method only, with no baseline variance, confidence intervals, or paired significance tests across the 30 tasks. A paired bootstrap or Wilcoxon signed-rank test over the 30 per-task means is needed to establish that the 0.0155 mean edge over EvoPrompt is not chance variation.
  3. [§3.3, Eq. (3.3.3), Table 2] The similarity regularizer is self-referential: h*_best is the embedding of the instruction with the highest evaluation score among the same scored instructions used to train the regressor, so Eq. (3.3.3) reinforces the current best rather than providing an independently validated optimization signal. Since removing SimReg changes the mean from 0.6955 to 0.6840 (Table 2), nearly the whole reported margin over EvoPrompt (0.0155) depends on this unvalidated heuristic. The authors should validate the predictor's score predictions on held-out instructions and compare the regularizer against a fixed or random semantic anchor.
  4. [Algorithm 1] Step 7 says 'Predict the next latent soft prompt z_t using N_s', but N_s is defined in Section 3.3 as a regression network that outputs a scalar reward prediction ŝ. The manuscript never specifies how a soft prompt is generated from this network, nor how z_t relates to the hidden representation h used to train N_s. Without this description the iterative optimization procedure is not reproducible.
minor comments (6)
  1. [Eq. (3.2.2), Eq. (3.2.3)] There are typos in these equations ('balck-box' and 'outpu'); please proofread the manuscript carefully.
  2. [Eq. (3.3.2)] The regression loss is written as a sum over i=1..N, while the text says i∈[N+T]; clarify whether the loss is computed only on the initial set or also on all iteration-generated instructions.
  3. [§3.3 and Table 5] The description of λ is inconsistent: Eq. (3.3.1) defines λ with dynamic bounds a and b, but the appendix Table 5 reports fixed 'SimReg-weight' values and the text claims a fixed value of 0.01 yields 0.6955, which is not what the table shows (the weight=0.01 row has mean 0.6742). Please reconcile the dynamic and fixed descriptions.
  4. [Figure 2] The figure is called a 'Normal Distribution Probability Graph' but the axes and reference lines are not defined; a standard Q-Q plot or an error-bar plot would be clearer.
  5. [Figure 3] The caption mixes two plots (evolution and ridgeline) without clear separation, and Section 4.3 refers to 'Figure 3 depicts the evolution...' twice in consecutive sentences.
  6. [Table 2] The header 'Black-box LLM Rep. Loss' is ambiguous; label the columns by the exact variant being ablated.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the final benchmark scores are external black-box evaluations, and the trained predictor is a fitted surrogate whose outputs are not reported as the paper's result.

full rationale

I examined the derivation chain for each load-bearing step. The score predictor N in Eq. (3.3.2) is trained on observed rewards, which is a standard fitted surrogate; however, the paper's reported results in Table 1 are actual black-box evaluation scores, not predictions from this surrogate. The similarity regularizer in Eq. (3.3.3) anchors on the current best instruction embedding, but Algorithm 1 updates the best instruction using ground-truth evaluation scores (lines 10-13), so the final comparison is not defined in terms of the regularizer's target. The method's improvement is measured against external baselines (InstructZero, EvoPrompt, APE, Instinct) and external initialization models, with no self-citation chain used to justify the central claim. The paper's 'consistently outperforms' wording is weakened by the task-level counts in Table 1 and the absence of significance tests, but that is an evidence and statistics concern, not circularity. No quoted reduction of an output to an input, no fitted parameter renamed as a prediction, and no load-bearing self-citation was found.

Assumptions & free parameters 5 free parameters · 4 assumptions · 0 invented entities

The method relies on domain assumptions about the informativeness of hidden representations and the validity of cosine similarity as an optimization signal, plus several unspecified hyperparameters (a, b) that affect the results. The paper's ablations show sensitivity to these choices, but the main text does not report them.

free parameters (5)
  • Dynamic weight bounds a, b = not reported
    In Eq. (3.3.1), lambda = max(a, min(b, L_Reg)); the paper never gives a or b, so the weighting is not reproducible.
  • Number of initial instructions N = 40
    Set in Section 3.1; chosen by the authors without sensitivity analysis.
  • Number of iterations T = 100 (inferred from Figure 4)
    The algorithm loops until a threshold or fixed T, but T is not stated in the text.
  • Neural network depth = 5 (best in Appendix A.5)
    The main text does not specify the depth; the appendix reports depth=5 as best but also shows an 'Ours' column with different scores.
  • Similarity loss weight lambda = dynamic (bounds unknown)
    Ablations use lambda=0.01 and lambda=1e-10; the dynamic scheme's bounds are not specified.
assumptions (4)
  • domain assumption Hidden representations from the white-box model Vicuna-13B capture instruction quality.
    Section 3.2 defines h and o and states they provide a richer and more stable foundation; no independent evidence is given.
  • domain assumption Cosine similarity between instruction embeddings is a meaningful measure of semantic consistency for optimization.
    Section 3.3 introduces cosine similarity as the basis of the similarity loss; this is a heuristic.
  • domain assumption Black-box generated instructions from ChatGPT-4o are effective and diverse enough for initialization.
    Section 3.1 assumes this; the ablation compares different initializers but does not isolate diversity.
  • domain assumption The white-box model can decode learned soft prompts into textual instructions.
    Algorithm 1 line 8 calls 'Generate instruction pi_t using M_W'; this is inherited from InstructZero without validation here.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Instruction Learning Paradigms: A Dual Perspective on White-box and Black-box LLMs." pith.science (2026). https://pith.science/paper/X4CID4ZG

@misc{pith2026250621573,
  author       = {Pith},
  title        = {Pith review of: Instruction Learning Paradigms: A Dual Perspective on White-box and Black-box LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/X4CID4ZG}},
  note         = {Machine review of arXiv:2506.21573}
}
read the original abstract

Optimizing instructions for large language models (LLMs) is critical for harnessing their full potential in complex and diverse tasks. However, relying solely on white-box approaches demands extensive computational resources and offers limited representational capacity, while black-box models can incur prohibitive financial costs. To address these challenges, we introduce a novel framework that seamlessly merges the strengths of both paradigms. Black-box models provide high-quality, diverse instruction initializations, and white-box models supply fine-grained interpretability through hidden states and output features. By enforcing a semantic similarity constraint, these components fuse into a unified high-dimensional representation that captures deep semantic and structural nuances, enabling an iterative optimization process to refine instruction quality and adaptability. Extensive evaluations across a broad spectrum of tasks-ranging from complex reasoning to cross-lingual generalization-demonstrate that our approach consistently outperforms state-of-the-art baselines. This fusion of black-box initialization with advanced semantic refinement yields a scalable and efficient solution, paving the way for next-generation LLM-driven applications in diverse real-world scenarios. The source code will be released soon.

Figures

Figures reproduced from arXiv: 2506.21573 by the authors.

Figure 1
Figure 1. Overview of our instruction learning framework. The framework integrates black-box initialization for generating [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Normal Distribution Probability Graph for Our Method (3 seeds) [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. (Left)Evolution of instruction performance across iterations for 5 tasks, and (Right) Ridgeline plot showing the score [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Performance difference between models with and without similarity regularization (SimReg) across 6 tasks. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]
Figure 5
Figure 5. Figure 5: Bubble chart comparison of task performance across different baselines: APE, EvoPrompt, INSTINCT, and In [PITH_FULL_IMAGE:figures/full_fig_p012_5.png]
Figure 6
Figure 6. Figure 6: Box plot comparing instruction optimization performance with and without similarity regularization (SimReg). [PITH_FULL_IMAGE:figures/full_fig_p015_6.png]
Figure 7
Figure 7. Figure 7: Ablation study on the impact of output representation. [PITH_FULL_IMAGE:figures/full_fig_p015_7.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

27 extracted references · 13 canonical work pages

  1. [1]

    T. B. Brown. Language models are few-shot learners.arXiv preprint arXiv:2005.14165, 2020

    arXiv 2005

  2. [2]

    L. Chen, J. Chen, T. Goldstein, H. Huang, and T. Zhou. Instructzero: Efficient instruction optimization for black-box large language models.arXiv preprint arXiv:2306.03082, 2023

    arXiv 2023

  3. [3]

    Chiang, Z

    W.-L. Chiang, Z. Li, Z. Lin, Y . Sheng, Z. Wu, H. Zhang, L. Zheng, S. Zhuang, Y . Zhuang, J. E. Gonzalez, et al. Vicuna: An open-source chatbot impressing gpt-4 with 90%* chatgpt quality.See https://vicuna. lmsys. org (accessed 14 April 2023), 2(3):6, 2023

    work page 2023

  4. [4]

    Q. Guo, R. Wang, J. Guo, B. Li, K. Song, X. Tan, G. Liu, J. Bian, and Y . Yang. Connecting large language models with evolutionary algorithms yields powerful prompt optimizers.arXiv preprint arXiv:2309.08532, 2023

    arXiv 2023

  5. [5]

    J. Hake, M. Crowley, A. Coy, D. Shanks, A. Eoff, K. Kirmer-V oss, G. Dhanda, and D. J. Parente. Quality, accuracy, and bias in chatgpt-based summarization of medical abstracts.The Annals of Family Medicine, 22(2):113–120, 2024

    work page 2024

  6. [6]

    Hoffmann, S

    J. Hoffmann, S. Borgeaud, A. Mensch, E. Buchatskaya, T. Cai, E. Rutherford, D. d. L. Casas, L. A. Hendricks, J. Welbl, A. Clark, et al. Training compute-optimal large language models.arXiv preprint arXiv:2203.15556, 2022

    arXiv 2022

  7. [7]

    Huang, K

    S. Huang, K. Yang, S. Qi, and R. Wang. When large language model meets optimization.arXiv preprint arXiv:2405.10098, 2024

    arXiv 2024

  8. [8]

    Do Models Really Learn to Follow Instructions? An Empirical Study of Instruction Tuning

    P.-N. Kung and N. Peng. Do models really learn to follow instructions? an empirical study of instruction tuning.arXiv preprint arXiv:2305.11383, 2023

    work page Pith review arXiv 2023

Show all 27 references
  1. [9]

    X. Lin, Z. Wu, Z. Dai, W. Hu, Y . Shu, S.-K. Ng, P. Jaillet, and B. K. H. Low. Use your instinct: Instruction optimization for llms using neural bandits coupled with transformers. InForty-first International Conference on Machine Learning, 2024

    2024

  2. [10]

    A. Liu, B. Feng, B. Xue, B. Wang, B. Wu, C. Lu, C. Zhao, C. Deng, C. Zhang, C. Ruan, et al. Deepseek-v3 technical report.arXiv preprint arXiv:2412.19437, 2024

    2024 arXiv

  3. [11]

    B. Liu, C. Chen, Z. Gong, C. Liao, H. Wang, Z. Lei, M. Liang, D. Chen, M. Shen, H. Zhou, et al. Mftcoder: Boosting code llms with multitask fine-tuning. InProceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pages 5430–5441, 2024

    2024

  4. [12]

    X. Liu, J. Wang, J. Sun, X. Yuan, G. Dong, P. Di, W. Wang, and D. Wang. Prompting frameworks for large language models: A survey.arXiv preprint arXiv:2311.12785, 2023

    2023 arXiv

  5. [13]

    Longpre, L

    S. Longpre, L. Hou, T. Vu, A. Webson, H. W. Chung, Y . Tay, D. Zhou, Q. V . Le, B. Zoph, J. Wei, et al. The flan collection: Designing data and methods for effective instruction tuning. InInternational Conference on Machine Learning, pages 22631–22648. PMLR, 2023

    2023

  6. [14]

    R. Lou, K. Zhang, and W. Yin. Large language model instruction following: A survey of progresses and challenges. Computational Linguistics, pages 1–10, 2024

    2024

  7. [15]

    Naveed, A

    H. Naveed, A. U. Khan, S. Qiu, M. Saqib, S. Anwar, M. Usman, N. Akhtar, N. Barnes, and A. Mian. A comprehensive overview of large language models.arXiv preprint arXiv:2307.06435, 2023

    2023 arXiv

  8. [16]

    Chatgpt, 2023

    OpenAI. Chatgpt, 2023. May 24 version [Large language model]

    2023

  9. [17]

    X. Sun, L. Dong, X. Li, Z. Wan, S. Wang, T. Zhang, J. Li, F. Cheng, L. Lyu, F. Wu, et al. Pushing the limits of chatgpt on nlp tasks.arXiv preprint arXiv:2306.09719, 2023

    2023 arXiv

  10. [18]

    Taori, I

    R. Taori, I. Gulrajani, T. Zhang, Y . Dubois, X. Li, C. Guestrin, P. Liang, and T. B. Hashimoto. Alpaca: A strong, replicable instruction-following model.Stanford Center for Research on Foundation Models. https://crfm. stanford. edu/2023/03/13/alpaca. html, 3(6):7, 2023

    2023

  11. [19]

    Y . Wang, S. Mishra, P. Alipoormolabashi, Y . Kordi, A. Mirzaei, A. Arunkumar, A. Ashok, A. S. Dhanasekaran, A. Naik, D. Stap, et al. Super-naturalinstructions: Generalization via declarative instructions on 1600+ nlp tasks.arXiv preprint arXiv:2204.07705, 2022

    2022 arXiv

  12. [20]

    White, S

    J. White, S. Hays, Q. Fu, J. Spencer-Smith, and D. C. Schmidt. Chatgpt prompt patterns for improving code quality, refactoring, requirements elicitation, and software design. InGenerative AI for Effective Software Development, pages 71–108. Springer, 2024

    2024

  13. [21]

    C. Xu, Q. Sun, K. Zheng, X. Geng, P. Zhao, J. Feng, C. Tao, and D. Jiang. Wizardlm: Empowering large language models to follow complex instructions.arXiv preprint arXiv:2304.12244, 2023

    2023 arXiv

  14. [22]

    Z. Yu, X. Zhang, N. Shang, Y . Huang, C. Xu, Y . Zhao, W. Hu, and Q. Yin. Wavecoder: Widespread and versatile enhanced instruction tuning with refined data generation.arXiv preprint arXiv:2312.14187, 2023

    2023 arXiv

  15. [23]

    Zhang, S

    J. Zhang, S. Vahidian, M. Kuo, C. Li, R. Zhang, T. Yu, G. Wang, and Y . Chen. Towards building the federatedgpt: Federated instruction tuning. InICASSP 2024-2024 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 6915–6919. IEEE, 2024

    2024

  16. [24]

    W. X. Zhao, K. Zhou, J. Li, T. Tang, X. Wang, Y . Hou, Y . Min, B. Zhang, J. Zhang, Z. Dong, et al. A survey of large language models.arXiv preprint arXiv:2303.18223, 2023

    2023 arXiv

  17. [25]

    Z. Zhao, E. Wallace, S. Feng, D. Klein, and S. Singh. Calibrate before use: Improving few-shot performance of language models. InInternational conference on machine learning, pages 12697–12706. PMLR, 2021

    2021

  18. [26]

    C. Zhou, P. Liu, P. Xu, S. Iyer, J. Sun, Y . Mao, X. Ma, A. Efrat, P. Yu, L. Yu, et al. Lima: Less is more for alignment. Advances in Neural Information Processing Systems, 36, 2024

    2024

  19. [27]

    The instruction was to,

    Y . Zhou, A. I. Muresanu, Z. Han, K. Paster, S. Pitis, H. Chan, and J. Ba. Large language models are human-level prompt engineers.arXiv preprint arXiv:2211.01910, 2022. 9 A. Appendix A.1. Initialization Prompt To guide ChatGPT in generating high-quality instructions, we utiliz...

    2022 arXiv

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.