Pith. sign in

REVIEW 4 major objections 7 minor 1 cited by

Smaller Language Models Are Better Instruction Evolvers

T0 review · 4 major / 7 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Smaller 7B–8B models evolve instruction-tuning data that outperforms data evolved by 70B+ models across three pipelines.

desk verdict SLM-evolved instructions consistently beat LLM-evolved ones across several setups, but the paper's size-based explanation is not clean and the scaling evidence is confounded. read the letter →

arxiv 2412.11231 v1 pith:N4YZHU4P submitted 2024-12-15 cs.CL

Tingfeng Hui , Lulu Zhao , Guanting Dong , Yaqi Zhang , Hua Zhou , Sen Su This is my paper · ORCID
classification cs.CL
keywords instructionevolutiontuningdatasynthesismodelscalingoutputdiversitylanguagemodelsselection
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 challenges the working assumption that bigger models are better at rewriting and generating training instructions. Across Evol-Instruct, AutoIF, and Auto Evol-Instruct, instruction data evolved by 7B–8B models outperformed data evolved by 70B+ models when either set was used to fine-tune the same backbone models. The authors attribute the advantage to a broader output space: smaller models assign lower probability to their top token, producing more complex and diverse instructions. If correct, this would make instruction-data synthesis cheaper and shift the scaling logic of data generation away from the largest available models.

What carries the argument

The central mechanism is the output space of the instruction-evolving model, measured by the distribution of top-1 token probabilities during generation: lower top-1 probability means a broader, less overconfident output distribution, which yields more complex and diverse instructions. The supporting object is the Instruction Complex-Aware IFD (IC-IFD) score, defined as $$\text{IC-IFD}_\Theta(Q,A) = \frac{\mathcal{L}_\Theta(A|Q)}{\mathcal{L}_\Theta(Q)\cdot\mathcal{L}_\Theta(A)},$$ which introduces instruction perplexity as a penalty into the original IFD score so that extremely hard instructions do not receive inflated quality estimates.

What would settle it

Run the three evolution scenarios with a matched pair of models that differ only in scale (same architecture, tokenizer, pretraining corpus, and alignment recipe), then fine-tune the same backbones on both instruction sets; if the larger model's data matches or beats the smaller model's data, the size-based claim fails. A second check: if the top-1 token probability distributions are equalized (e.g., by temperature scaling), the performance gap should disappear if the output-space explanation is the active cause.

Watch

Extended reading notes

Core claim

The central claim is that, for the purpose of evolving instruction-tuning data, smaller language models are more effective than their larger counterparts. In three instruction-evolution scenarios, datasets produced by 7B–8B models consistently led to better fine-tuned performance on instruction following, math reasoning, and code generation than datasets produced by 70B+ models from the same model families. The paper explains this through the distribution of top-1 token probabilities: the larger models are more confident in each generated token, narrowing their output space, whereas smaller models sample from a wider distribution and therefore generate instructions that are more complex and diverse. The paper also introduces IC-IFD, a data-quality score that penalizes the original IFD score by instruction complexity, and shows it predicts downstream fine-tuning gains better when selecting subsets of evolved instructions.

Load-bearing premise

The conclusion that smaller size causes better instruction evolution assumes the measured advantage comes from model size rather than from other differences between the compared models, such as pretraining data, alignment recipe, or fine-tuning method.

Editorial extensions

If this is right

  • Data evolved by 7B–8B models can replace data evolved by 70B+ models without a loss in fine-tuned performance, cutting the compute and API cost of instruction data construction.
  • Evolving with smaller models can reach the same or better instruction complexity in fewer iterations than evolving with larger models.
  • High-complexity instructions are not always better: after two rounds of SLM evolution, a third round can overshoot and degrade performance, which IC-IFD flags by penalizing instruction difficulty.
  • IC-IFD can be used to filter instruction data without running instruction tuning, outperforming instruction length, instruction perplexity, and the original IFD at the tested selection ratios.

Reading between the lines

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

  • A testable extension beyond the paper: match the output entropy or sampling temperature of the 70B model to that of the 8B model; if the performance gap closes, the output-space explanation, rather than model size per se, is the active variable.
  • The result suggests that instruction evolution is a regime where teaching ability does not monotonically track the teacher's own capability, analogous to findings for response generation, so data-synthesis pipelines should benchmark the data product rather than the generator's benchmark scores.
  • The IC-IFD penalty could plausibly be applied beyond Evol-Instruct-style pipelines, for example to filter any instruction dataset where difficulty is skewed, though the paper only demonstrates it on Alpaca and evolved Alpaca data.
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 / 7 minor

Summary. The paper asks whether smaller language models (SLMs, 7-8B) synthesize more effective instruction-tuning data than larger models (LLMs, 70B+) under three instruction-evolution pipelines: Evol-Instruct, AutoIF, and Auto Evol-Instruct. Using Llama-3.1 and Qwen-2 families as instruction evolvers and a range of backbone models as downstream fine-tuning targets, the authors report that SLM-evolved instructions generally produce better or comparable downstream performance than LLM-evolved instructions. They connect this to a broader output space of SLMs via lower top-1 token probabilities, and they introduce an instruction-complexity-penalized version of the IFD score (IC-IFD) as a training-free way to evaluate instruction data. The paper includes a scaling study across Qwen-2.5 downstream models from 0.5B to 72B.

Significance. If the main finding is robust, the paper is practically significant: it would imply that instruction-evolution pipelines can be run with much smaller and cheaper models without sacrificing data quality, and it would challenge the common practice of delegating instruction synthesis to frontier or 70B+ models. The study has genuine strengths: it evaluates multiple downstream backbones, uses two model families for the main Evol-Instruct comparison, fixes the evolution prompt sequence to reduce confounds within a pair, holds the response generator constant, and releases code. The token-probability analysis is a plausible and testable mechanism. However, the causal attribution to 'size' is currently not established as cleanly as the title suggests, and the IC-IFD validation is partially circular. With matched training setups, additional evolver-size points, and repeated runs, the evidence could be made convincing.

major comments (4)
  1. [§3.1, 'Scaling Experiments', Figure 3, Table 7, Table 11] The scaling experiment varies the size of the downstream fine-tuned model while keeping the instruction-evolution models fixed (Llama-3.1-8B vs Llama-3.1-70B), and the downstream training setup is confounded: 0.5B-7B use full fine-tuning (LR 1e-5 or 7e-6) while 14B-72B use LoRA (LR 5e-5). The step from 7B to 14B in Figure 3 could reflect the change in tuning method and learning rate rather than model size. As a consequence, the statement that the findings 'hold across models of different sizes' is not yet established. Please provide a matched training setup and seed variance for at least the 7B vs 14B comparison.
  2. [§3.1 and Tables 1-4] The direct evidence for the title claim is a single 7-8B vs 70B+ comparison in each of two model families (plus single-family AutoIF and Auto Evol-Instruct comparisons). Because the compared supervisors differ not only in size but also in pretraining data, alignment procedure, and possibly instruction-following strength, the pairwise results do not establish a general size law; they establish that the two specific SLMs are more effective than their two specific larger counterparts in these three scenarios. The scaling experiment in Figure 3 does not vary the evolver size, so it cannot fill this gap. A size sweep of evolution models within one family, with fixed prompt and data construction, would let the title claim be made without overreach.
  3. [§5, 'Performance of IC-IFD', Table 5, and Limitation (3)] IC-IFD is designed from the observed performance degradation on Alpaca-iter3 (Section 3.1, Figure 1) and then validated by filtering exactly that dataset (Table 5). This is a post hoc evaluation on the same data that motivated the metric. The AlpacaFarm comparisons in Appendix A.4 (Figures 6-7) are a step in the right direction, but they use the original Alpaca data rather than a different evolution round or dataset. Please validate IC-IFD on held-out instruction sets (e.g., GSM8K or Code Alpaca iter-3, or LLM-evolved iter-3) to support the claim that it 'more accurately' assesses instruction data.
  4. [Throughout §3, especially Table 2] No repeated runs or significance tests are reported anywhere, and not every cell favors SLM-INST: for example, in Table 2 the Llama-3-8B model reaches 63.76 on GSM8K with Qwen-2-72B-evolved instructions versus 63.91 with Qwen-2-7B-evolved instructions. Many other differences are small enough that they could be within run-to-run noise. The headline conclusion relies on point estimates. Please report at least three independent seeds with means and standard deviations, or paired significance tests, for the main SLM-vs-LLM comparisons and for the scaling curves.
minor comments (7)
  1. [Section 1, RQ2 heading] The heading reads 'Why do SLMs Outerperform LLMs' and the word should be 'Outperform'.
  2. [Equation (2)] The denominator introduces LΘ(Q) but the text describes it as 'perplexity'; please clarify whether LΘ(Q) is the average cross-entropy loss and how it is normalized by sequence length, since average cross-entropy loss is not perplexity unless exponentiated.
  3. [Figure 3] The caption and legend should explicitly state that the x-axis is the size of the fine-tuned downstream model, and that the two curves correspond to instructions evolved by the Llama-3.1-8B and Llama-3.1-70B supervisors; the full-fine-tuning vs LoRA split should be marked in the figure.
  4. [Table 7] The learning-rate rows do not indicate which training regime they belong to; given the full fine-tuning/LoRA split, please add a column or note so the reader can see which learning rate applies to each size and method.
  5. [Section 3.3] The statement that SLMs generate 6.9% more trajectory keywords is used to support Finding 3, but the underlying counts are not reported in any table or appendix; please include them.
  6. [Section 4 and Figure 5] The token-probability analysis is only reported for one model pair (Llama-3.1-8B vs Llama-3.1-70B) and one scenario; please state whether the distribution difference is statistically significant and whether it is also observed in the Qwen family.
  7. [Sections 3.2 and 3.3] AutoIF and Auto Evol-Instruct report only the Llama-3.1 family; the abstract's claim of consistency across scenarios would benefit from an explicit statement that these two scenarios are currently single-family demonstrations.

Circularity Check

1 steps flagged · score 3.0 of 10

Central SLM-vs-LLM finding is grounded in external benchmarks and is not circular; the IC-IFD metric carries a partial post hoc circularity because its complexity penalty is derived from, and validated on, the same iter3 degradation.

  1. other [Section 5, Eq. (2), Table 5; Limitations (3)]
    "The IC-IFD we propose is based on our observation that performance degrades with the emergence of high-difficulty instructions, which leads us to introduce instruction complexity as a penalty term in the original IFD."

    Equation (2) inserts instruction perplexity L(Q) into the denominator, IC-IFD = L(A|Q)/(L(Q)*L(A)), so high-complexity instructions receive lower scores by construction. The paper states this penalty was motivated by the observed iter3 degradation caused by excessive difficulty (Figure 2 shows nearly 70% of SLM Alpaca iter3 instructions are 'very hard'; Table 15), and then validates the metric on the same Alpaca-iter3 SLM data (Table 5). Retaining the top 25% by IC-IFD is, to first order, selecting the low-L(Q) examples the design was built to favor. The improvement over IFD on that dataset therefore recapitulates the design objective rather than providing an independent test.

full rationale

The paper's main claim—that instruction data evolved by 7B-8B SLMs outperforms data evolved by 70B+ LLMs—is evaluated on standard external benchmarks (IFEval, GSM8K, MATH, HumanEval, MBPP, FollowBench, C-Eval, MMLU) after fine-tuning several backbone models. No equation defining that comparison reduces to an input, and no fitted parameter is renamed as a prediction. The scaling experiment's full-tuning-versus-LoRA split is a validity confound, not a circularity. The one partially circular component is IC-IFD (Section 5): Eq. (2) divides by instruction perplexity as a complexity penalty, explicitly motivated by the observed iter3 degradation, and Table 5 validates the metric on that same iter3 dataset. The Limitations section candidly states this post hoc origin. Because the central SLM-vs-LLM result does not depend on IC-IFD, and the main experiments are self-contained against external benchmarks, the overall circularity is mild.

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

The ledger shows the main claim rests on standard domain assumptions about benchmark validity and measurement; the IC-IFD metric introduces one hand-chosen design choice (unit penalty exponent) and one unvalidated complexity proxy (instruction PPL). No invented entities are introduced.

free parameters (1)
  • IC-IFD complexity penalty exponent = 1 (implicit)
    Eq. (2) divides IFD by L(Q) to the first power; the choice of unit exponent is made by hand and not searched or justified by theory.
assumptions (5)
  • domain assumption Downstream SFT benchmark performance is a valid proxy for instruction quality.
    Section 3.1 defines 'effective' via fine-tuned model scores on IFEval, GSM8K, MATH, HumanEval, MBPP.
  • domain assumption A fixed response generator (Qwen-2.5-72B-Instruct) isolates instruction evolution effects.
    Section 3.1 states responses are consistently generated by Qwen-2.5-72B-Instruct; if response quality interacts with instruction quality, the isolation is imperfect.
  • domain assumption Fixed evolution-method sequence is fair across SLM and LLM.
    Appendix A.1 applies the four in-depth methods in a fixed sequence instead of random selection to reduce variation; this presumes order effects are minimal.
  • domain assumption Qwen-2.5-72B-Instruct difficulty labels reliably reflect instruction complexity.
    Figures 2 and Table 13 use these labels for the complexity analysis; no human validation is reported.
  • ad hoc to paper Instruction perplexity L(Q) measures instruction complexity.
    Eq. (2) introduces L(Q) as the complexity penalty; the paper treats higher L(Q) as harder instructions without independent validation.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Smaller Language Models Are Better Instruction Evolvers." pith.science (2026). https://pith.science/paper/N4YZHU4P

@misc{pith2026241211231,
  author       = {Pith},
  title        = {Pith review of: Smaller Language Models Are Better Instruction Evolvers},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/N4YZHU4P}},
  note         = {Machine review of arXiv:2412.11231}
}
read the original abstract

Instruction tuning has been widely used to unleash the complete potential of large language models. Notably, complex and diverse instructions are of significant importance as they can effectively align models with various downstream tasks. However, current approaches to constructing large-scale instructions predominantly favour powerful models such as GPT-4 or those with over 70 billion parameters, under the empirical presumption that such larger language models (LLMs) inherently possess enhanced capabilities. In this study, we question this prevalent assumption and conduct an in-depth exploration into the potential of smaller language models (SLMs) in the context of instruction evolution. Extensive experiments across three scenarios of instruction evolution reveal that smaller language models (SLMs) can synthesize more effective instructions than LLMs. Further analysis demonstrates that SLMs possess a broader output space during instruction evolution, resulting in more complex and diverse variants. We also observe that the existing metrics fail to focus on the impact of the instructions. Thus, we propose Instruction Complex-Aware IFD (IC-IFD), which introduces instruction complexity in the original IFD score to evaluate the effectiveness of instruction data more accurately. Our source code is available at: \href{https://github.com/HypherX/Evolution-Analysis}{https://github.com/HypherX/Evolution-Analysis}

Figures

Figures reproduced from arXiv: 2412.11231 by the authors.

Figure 1
Figure 1. Comparison of performance on Llama-3-8B during three iterations of instruction evolution, using Llama [PITH_FULL_IMAGE:figures/full_fig_p004_1.png] view at source ↗
Figure 2
Figure 2. Distribution of difficulty levels for instructions evolved during three iterations, using Llama-3.1-8B [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. Comparison of performance among Qwen-2.5 series models. Detailed results can be found in Table [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (17 more)
Figure 4
Figure 4. Figure 4: Distribution of Minimum Neighbor Distance [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Comparison of output token probability distri [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]
Figure 6
Figure 6. Figure 6: Performance comparison of three data selec [PITH_FULL_IMAGE:figures/full_fig_p014_6.png]
Figure 7
Figure 7. Figure 7: Performance comparison of three data selec [PITH_FULL_IMAGE:figures/full_fig_p014_7.png]
Figure 8
Figure 8. Figure 8: Comparison of cases between LLMs and SLMs under adding constraints strategy. [PITH_FULL_IMAGE:figures/full_fig_p017_8.png]
Figure 9
Figure 9. Figure 9: Comparison of cases between LLMs and SLMs under deepening strategy. [PITH_FULL_IMAGE:figures/full_fig_p017_9.png]
Figure 10
Figure 10. Figure 10: In-depth evolution prompt template utilized in Evol-Instruct scenario. [PITH_FULL_IMAGE:figures/full_fig_p018_10.png]
Figure 11
Figure 11. Figure 11: Four in-depth methods utilized in Evol-Instruct scenario. [PITH_FULL_IMAGE:figures/full_fig_p018_11.png]
Figure 12
Figure 12. Figure 12: In-breadth evolution prompt template utilized in Evol-Instruct scenario. [PITH_FULL_IMAGE:figures/full_fig_p018_12.png]
Figure 13
Figure 13. Figure 13: Prompt template of Self-Instruct Seed Instructions in AutoIF scenario. [PITH_FULL_IMAGE:figures/full_fig_p018_13.png]
Figure 14
Figure 14. Figure 14: Prompt template of Verification Funcs and Cases Generation in AutoIF scenario. [PITH_FULL_IMAGE:figures/full_fig_p019_14.png]
Figure 15
Figure 15. Figure 15: Prompt template of Auto Evol-Instruct scenario. [PITH_FULL_IMAGE:figures/full_fig_p019_15.png]
Figure 16
Figure 16. Figure 16: Prompt template of response generation. 19 [PITH_FULL_IMAGE:figures/full_fig_p019_16.png]
Figure 17
Figure 17. Figure 17: Prompt template of evaluating the difficulty levels. [PITH_FULL_IMAGE:figures/full_fig_p020_17.png]
Figure 18
Figure 18. Figure 18: Prompt template of extracting the keywords from evolution trajectories. [PITH_FULL_IMAGE:figures/full_fig_p020_18.png]
Figure 19
Figure 19. Figure 19: Prompt template of evaluating the difficulty scores. [PITH_FULL_IMAGE:figures/full_fig_p020_19.png]
Figure 20
Figure 20. Figure 20: Prompt template of evaluating the win-tie-lose rates. [PITH_FULL_IMAGE:figures/full_fig_p021_20.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Tag-Evol: Achieving Efficient Instruction Evolving via Tag Injection

    cs.CL 2025-05 conditional novelty 6.0 of 10

    Tag-Evol generates harder, more diverse instruction data by injecting sampled knowledge tags into seed instructions, improving downstream SFT accuracy across math, code, and general benchmarks.

Reference graph

Works this paper leans on

42 extracted references · 9 canonical work pages · cited by 1 Pith paper

  1. [1]

    Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie J

    Jacob Austin, Augustus Odena, Maxwell I. Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie J. Cai, Michael Terry, Quoc V. Le, and Charles Sutton. 2021. https://arxiv.org/abs/2108.07732 Program synthesis with large language models . CoRR, abs/2108.07732

    arXiv 2021

  2. [2]

    Xiao Bi, Deli Chen, Guanting Chen, Shanhuang Chen, Damai Dai, Chengqi Deng, Honghui Ding, Kai Dong, Qiushi Du, Zhe Fu, Huazuo Gao, Kaige Gao, Wenjun Gao, Ruiqi Ge, Kang Guan, Daya Guo, Jianzhong Guo, Guangbo Hao, Zhewen Hao, Ying He, Wenjie Hu, Panpan Huang, Erhang Li, Guowei Li, Jiashi Li, Yao Li, Y. K. Li, Wenfeng Liang, Fangyun Lin, Alex X. Liu, Bo Liu...

    arXiv doi:10.48550/arxiv.2401.02954 2024

  3. [3]

    Zheng Cai, Maosong Cao, Haojiong Chen, Kai Chen, Keyu Chen, Xin Chen, Xun Chen, Zehui Chen, Zhi Chen, Pei Chu, Xiaoyi Dong, Haodong Duan, Qi Fan, Zhaoye Fei, Yang Gao, Jiaye Ge, Chenya Gu, Yuzhe Gu, Tao Gui, Aijia Guo, Qipeng Guo, Conghui He, Yingfan Hu, Ting Huang, Tao Jiang, Penglong Jiao, Zhenjiang Jin, Zhikai Lei, Jiaxing Li, Jingwen Li, Linyang Li, S...

    arXiv doi:10.48550/arxiv.2403.17297 2024

  4. [4]

    Sahil Chaudhary. 2023. Code alpaca: An instruction-following llama model for code generation. https://github.com/sahil280114/codealpaca

    2023

  5. [5]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Pond \' e de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bava...

    arXiv 2021

  6. [6]

    Gonzalez, Ion Stoica, and Eric P

    Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph E. Gonzalez, Ion Stoica, and Eric P. Xing. 2023. https://lmsys.org/blog/2023-03-30-vicuna/ Vicuna: An open-source chatbot impressing gpt-4 with 90\

    2023

  7. [7]

    Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. 2021. https://arxiv.org/abs/2110.14168 Training verifiers to solve math word problems . CoRR, abs/2110.14168

    arXiv 2021

  8. [8]

    OpenCompass Contributors. 2023. Opencompass: A universal evaluation platform for foundation models. https://github.com/open-compass/opencompass

    2023

Show all 42 references
  1. [9]

    Guanting Dong, Keming Lu, Chengpeng Li, Tingyu Xia, Bowen Yu, Chang Zhou, and Jingren Zhou. 2024. https://doi.org/10.48550/ARXIV.2406.13542 Self-play with execution feedback: Improving instruction-following capabilities of large language models . CoRR, abs/2406.13542

    2024 doi arXiv

  2. [10]

    Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al - Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, Anirudh Goyal, Anthony Hartshorn, Aobo Yang, Archi Mitra, Archie Sravankumar, Artem Korenev, Arthur Hinsvark, Arun Rao, Aston Z...

    2024 doi arXiv

  3. [11]

    Hashimoto

    Yann Dubois, Chen Xuechen Li, Rohan Taori, Tianyi Zhang, Ishaan Gulrajani, Jimmy Ba, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. http://papers.nips.cc/paper\_files/paper/2023/hash/5fc47800ee5b30b8777fdd30abcaaf3b-Abstract-Conference.html Alpacafarm: A simul...

    2023

  4. [12]

    Dan Hendrycks, Collin Burns, Steven Basart, Andy Zou, Mantas Mazeika, Dawn Song, and Jacob Steinhardt. 2021 a . https://openreview.net/forum?id=d7KBjmI3GmQ Measuring massive multitask language understanding . In 9th International Conference on Learning Representations, ICLR 20...

    2021

  5. [13]

    Dan Hendrycks, Collin Burns, Saurav Kadavath, Akul Arora, Steven Basart, Eric Tang, Dawn Song, and Jacob Steinhardt. 2021 b . https://datasets-benchmarks-proceedings.neurips.cc/paper/2021/hash/be83ab3ecd0db773eb2dc1b0a17836a1-Abstract-round2.html Measuring mathematical problem...

    2021

  6. [14]

    Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen - Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen

    Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen - Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2022. https://openreview.net/forum?id=nZeVKeeFYf9 Lora: Low-rank adaptation of large language models . In The Tenth International Conference on Learning Representat...

    2022

  7. [15]

    Yuzhen Huang, Yuzhuo Bai, Zhihao Zhu, Junlei Zhang, Jinghan Zhang, Tangjun Su, Junteng Liu, Chuancheng Lv, Yikai Zhang, Jiayi Lei, Yao Fu, Maosong Sun, and Junxian He. 2023. http://papers.nips.cc/paper\_files/paper/2023/hash/c6ec1844bec96d6d32ae95ae694e23d8-Abstract-Datasets\_...

    2023

  8. [16]

    Albert Q. Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de Las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, L \' e lio Renard Lavaud, Marie - Anne Lachaux, Pierre Stock, Teven Le Scao, Thibaut Lavril, ...

    2023 doi arXiv

  9. [17]

    Yuxin Jiang, Yufei Wang, Xingshan Zeng, Wanjun Zhong, Liangyou Li, Fei Mi, Lifeng Shang, Xin Jiang, Qun Liu, and Wei Wang. 2024. https://doi.org/10.18653/V1/2024.ACL-LONG.257 Followbench: A multi-level fine-grained constraints following benchmark for large language models . In...

    2024 doi

  10. [18]

    o pf, Yannic Kilcher, Dimitri von R \

    Andreas K \" o pf, Yannic Kilcher, Dimitri von R \" u tte, Sotiris Anagnostidis, Zhi Rui Tam, Keith Stevens, Abdullah Barhoum, Duc Nguyen, Oliver Stanley, Rich \' a rd Nagyfi, Shahul ES, Sameer Suri, David Glushkov, Arnav Dantuluri, Andrew Maguire, Christoph Schuhmann, Huu Ngu...

    2023

  11. [19]

    Woosuk Kwon, Zhuohan Li, Siyuan Zhuang, Ying Sheng, Lianmin Zheng, Cody Hao Yu, Joseph Gonzalez, Hao Zhang, and Ion Stoica. 2023. https://doi.org/10.1145/3600006.3613165 Efficient memory management for large language model serving with pagedattention . In Proceedings of the 29...

    2023

  12. [20]

    Ming Li, Yong Zhang, Zhitao Li, Jiuhai Chen, Lichang Chen, Ning Cheng, Jianzong Wang, Tianyi Zhou, and Jing Xiao. 2024. https://doi.org/10.18653/V1/2024.NAACL-LONG.421 From quantity to quality: Boosting LLM performance with self-guided data selection for instruction tuning . I...

    2024 doi

  13. [21]

    Wei Liu, Weihao Zeng, Keqing He, Yong Jiang, and Junxian He. 2024. https://openreview.net/forum?id=BTKAeLqLMw What makes good data for alignment? A comprehensive study of automatic data selection in instruction tuning . In The Twelfth International Conference on Learning Repre...

    2024

  14. [22]

    Haipeng Luo, Qingfeng Sun, Can Xu, Pu Zhao, Jianguang Lou, Chongyang Tao, Xiubo Geng, Qingwei Lin, Shifeng Chen, and Dongmei Zhang. 2023. https://doi.org/10.48550/ARXIV.2308.09583 Wizardmath: Empowering mathematical reasoning for large language models via reinforced evol-instr...

    2023 doi arXiv

  15. [23]

    Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2024. https://openreview.net/forum?id=UnUwSIgK5W Wizardcoder: Empowering code large language models with evol-instruct . In The Twelfth International Confe...

    2024

  16. [24]

    OpenAI. 2023. https://doi.org/10.48550/ARXIV.2303.08774 GPT-4 technical report . CoRR, abs/2303.08774

    2023 doi arXiv

  17. [25]

    Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll L. Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, John Schulman, Jacob Hilton, Fraser Kelton, Luke Miller, Maddie Simens, Amanda Askell, Peter Welinder, Paul F. Christiano, Jan Leik...

    2022

  18. [26]

    Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, and Tie - Yan Liu. 2020. https://proceedings.neurips.cc/paper/2020/hash/c3a690be93aa602ee2dc0ccab5b7b67e-Abstract.html Mpnet: Masked and permuted pre-training for language understanding . In Advances in Neural Information Processing S...

    2020

  19. [27]

    Hashimoto

    Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. 2023. Stanford alpaca: An instruction-following llama model. https://github.com/tatsu-lab/stanford_alpaca

    2023

  20. [28]

    Qwen Team. 2024. https://qwenlm.github.io/blog/qwen2.5/ Qwen2.5: A party of foundation models

    2024

  21. [29]

    Smith, Daniel Khashabi, and Hannaneh Hajishirzi

    Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2023. https://doi.org/10.18653/V1/2023.ACL-LONG.754 Self-instruct: Aligning language models with self-generated instructions . In Proceedings of the 61st Annual Mee...

    2023 doi

  22. [30]

    Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, Qingwei Lin, and Daxin Jiang. 2024 a . https://openreview.net/forum?id=CfXh93NDgH Wizardlm: Empowering large pre-trained language models to follow complex instructions . In The Twelfth Internati...

    2024

  23. [31]

    Zhangchen Xu, Fengqing Jiang, Luyao Niu, Yuntian Deng, Radha Poovendran, Yejin Choi, and Bill Yuchen Lin. 2024 b . https://doi.org/10.48550/ARXIV.2406.08464 Magpie: Alignment data synthesis from scratch by prompting aligned llms with nothing . CoRR, abs/2406.08464

    2024 doi arXiv

  24. [32]

    Zhangchen Xu, Fengqing Jiang, Luyao Niu, Bill Yuchen Lin, and Radha Poovendran. 2024 c . https://arxiv.org/abs/2411.07133 Stronger models are not stronger teachers for instruction tuning . Preprint, arXiv:2411.07133

    2024 arXiv

  25. [33]

    An Yang, Baosong Yang, Binyuan Hui, Bo Zheng, Bowen Yu, Chang Zhou, Chengpeng Li, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jialong Tang, Jialin Wang, Jian Yang, Jianhong Tu, Jianwei Zhang, Jianxin Ma, Jianxin Yang, Jin Xu, Jingren Zhou, Jinze...

    2024 doi arXiv

  26. [34]

    Weihao Zeng, Can Xu, Yingxiu Zhao, Jian - Guang Lou, and Weizhu Chen. 2024. https://aclanthology.org/2024.emnlp-main.397 Automatic instruction evolving for large language models . In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, EMNLP ...

    2024

  27. [35]

    Shengyu Zhang, Linfeng Dong, Xiaoya Li, Sen Zhang, Xiaofei Sun, Shuhe Wang, Jiwei Li, Runyi Hu, Tianwei Zhang, Fei Wu, and Guoyin Wang. 2023. https://doi.org/10.48550/ARXIV.2308.10792 Instruction tuning for large language models: A survey . CoRR, abs/2308.10792

    2023 doi

  28. [36]

    Wenting Zhao, Xiang Ren, Jack Hessel, Claire Cardie, Yejin Choi, and Yuntian Deng. 2024. https://openreview.net/forum?id=Bl8u7ZRlbM Wildchat: 1m chatgpt interaction logs in the wild . In The Twelfth International Conference on Learning Representations, ICLR 2024, Vienna, Austr...

    2024

  29. [37]

    Xing, Joseph E

    Lianmin Zheng, Wei - Lin Chiang, Ying Sheng, Tianle Li, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zhuohan Li, Zi Lin, Eric P. Xing, Joseph E. Gonzalez, Ion Stoica, and Hao Zhang. 2024 a . https://openreview.net/forum?id=BOfDKxfwt0 Lmsys-chat-1m: A large-scale real-world LLM ...

    2024

  30. [38]

    Yaowei Zheng, Richong Zhang, Junhao Zhang, Yanhan Ye, Zheyan Luo, and Yongqiang Ma. 2024 b . https://doi.org/10.48550/ARXIV.2403.13372 Llamafactory: Unified efficient fine-tuning of 100+ language models . CoRR, abs/2403.13372

    2024 doi arXiv

  31. [39]

    Chunting Zhou, Pengfei Liu, Puxin Xu, Srinivasan Iyer, Jiao Sun, Yuning Mao, Xuezhe Ma, Avia Efrat, Ping Yu, Lili Yu, Susan Zhang, Gargi Ghosh, Mike Lewis, Luke Zettlemoyer, and Omer Levy. 2023 a . http://papers.nips.cc/paper\_files/paper/2023/hash/ac662d74829e4407ce1d126477f4...

    2023

  32. [40]

    Jeffrey Zhou, Tianjian Lu, Swaroop Mishra, Siddhartha Brahma, Sujoy Basu, Yi Luan, Denny Zhou, and Le Hou. 2023 b . https://doi.org/10.48550/ARXIV.2311.07911 Instruction-following evaluation for large language models . CoRR, abs/2311.07911

    2023 doi arXiv

  33. [41]

    online" 'onlinestring :=

    ENTRY address archivePrefix author booktitle chapter edition editor eid eprint eprinttype howpublished institution journal key month note number organization pages publisher school series title type volume year doi pubmed url lastchecked label extra.label sort.label short.list...

  34. [42]

    write newline

    " write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 gl...

Pith tools

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