Tag-Evol: Achieving Efficient Instruction Evolving via Tag Injection

Chuanzhe Guo; Qingfu Zhu; Shiqi Zhou; Yixuan Wang

REVIEW 4 major objections 5 minor 33 references

Tag-Evol: Achieving Efficient Instruction Evolving via Tag Injection

T0 review · 4 major / 5 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 The paper proposes Tag-Evol, a method that uses fine-grained knowledge tags as evolution strategies to generate harder and more diverse instruction data, reporting average gains of 2-3 points over Evol-Instruct on six benchmarks.

desk verdict A genuinely new data-evolution mechanism with a strong experimental setup, but the headline 2-3 point improvement rests on single unseeded runs; the efficiency claim is asserted, not measured. read the letter →

arxiv 2505.24165 v1 pith:ZMFNRWPN submitted 2025-05-30 cs.CL

Yixuan Wang , Shiqi Zhou , Chuanzhe Guo , Qingfu Zhu This is my paper

classification cs.CL

keywords instructionevolutionknowledgetagstaginjectionsyntheticdatasupervisedfine-tuningEvol-InstructdiversityLLMsynthesis

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 proposes Tag-Evol, a method for synthesizing instruction-tuning data that replaces the fixed, hand-designed evolution strategies of Evol-Instruct with large pools of fine-grained knowledge tags. Each tag stands for a specific attribute an evolved instruction could build on, such as exponentiation, regex, or a condition on variables; sampling a batch of tags and injecting a chosen subset into a seed instruction shifts the difficulty in one pass instead of several rounds of rewriting. The authors report that models fine-tuned on Tag-Evol evolved data outperform models trained on Evol-Instruct or Auto Evol-Instruct data by 2 to 3 points on average across MT-Bench, IFEval, GSM8K, MATH-500, HumanEval, and MBPP, under matched seed data and base models. If correct, the result matters because it makes hard-sample synthesis cheaper and more adaptive to a target domain.

What carries the argument

The central object is the tag pool: a set of fine-grained knowledge tags organized by aspects, built by first asking the model to summarize a seed instruction's abstract characteristics (required skills, task types, kinds of arithmetic) and then asking it to produce concrete tags under each aspect. During evolution, the model receives a candidate batch of tags and a difficulty budget $b$; it selects a subset of size $b$ that fits the instruction, plans an injection, and rewrites the instruction to incorporate the tags, optionally rewriting to remove hallucinations. The budget-control injection, written $\hat{x}, t = M_\theta(x, b, \text{cand})$, is what lets Tag-Evol generate hard samples in one shot, because the number and combination of tags set the difficulty instead of repeated iterative deepening.

What would settle it

Run Tag-Evol on a fourth domain (for example, medical or legal reasoning) using only tags extracted from that domain's own seed set and compare against Evol-Instruct under the same base model; if the 2-3 point improvement does not reproduce, the cross-domain tag-quality assumption is falsified.

Watch

Extended reading notes

Core claim

The central claim is that knowledge tags can serve as evolution strategies, and that injecting them into seed instructions yields evolved data that is both harder and more diverse than iterative Evol-Instruct. Concretely, the paper argues that a domain-specific tag pool of thousands of specific tags, built by a multi-step fine-grained tagging method, provides far richer guidance than a small set of generic evolution prompts, and that controlling the number of injected tags produces samples of varying difficulty in a single generation call. The empirical claim is that Tag-Evol outperforms Evol-Instruct and Auto Evol-Instruct at every backbone setting tested, with an average improvement of 2-3 points across six benchmarks and about 1.5 points on the strongest backbone (Qwen2.5-7B).

Load-bearing premise

That tags extracted from a domain's seed data are specific and diverse enough to act as evolution strategies in every domain; the paper directly tests tagging quality only on math.

Editorial extensions

If this is right

Because strategies are sampled from a tag pool rather than hand-written, applying Tag-Evol to a new domain reduces to tagging a seed set; no prompt engineering for evolution strategies is needed.
Budget $b$ becomes a direct difficulty control: changing the number of injected tags changes the hardness of the generated dataset, enabling curriculum construction.
Because each round evolves directly from the seed rather than from the previous round's output, synthesis avoids cumulative hallucination errors and is cheaper at equal dataset size.
The finding that 7B-level models can execute tag injection well implies the method is usable in settings where only open-weight models are available.

Reading between the lines

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

Editorial extension: if high-quality tags from external sources are mixed into the seed-derived pool, evolution could inject knowledge the seed set does not contain; the paper lists this as future work, and it suggests a route to domain coverage beyond the seed.
Editorial extension: the budget parameter suggests a calibration experiment the paper does not run: holding the seed fixed, downstream score should rise monotonically, then plateau, as budget increases; observing where it plateaus would give a principled choice of budgets.
Editorial extension: the tag-pool framing implies a reusable asset: a curated domain tag pool could be maintained once and reused to evolve arbitrary new instruction sets, turning data synthesis into a cheaper, asset-based operation.

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.

Desk Editor's Note

read the letter

Tag-Evol is a genuine conceptual step in instruction evolution. The core move—replacing the fixed set of hand-designed evolution prompts with a pool of fine-grained knowledge tags, then controlling difficulty by injecting a budgeted number of tags—is new and cleanly motivated. The two-step tagging method (aspects first, then concrete tags) is a sensible way to get more specific tags, and the authors show it produces far more tags than the original InsTag. The experimental setup is also more careful than many papers in this area: three base models, three domains, baselines re-implemented under the same open-source configuration, and a leakage check. The multi-round analysis showing Tag-Evol's advantage across data scales is more informative than a single headline number.

The main weakness is the statistical ground under the headline claim. The abstract and Section 4.2 say Tag-Evol 'significantly outperforms' the baselines, but Table 2 reports one SFT run per condition. No seeds, no error bars, no significance test. On these benchmarks, run-to-run variance is typically in the 1-2 point range, and several of the per-task differences in Table 2 are smaller than that. The aggregate 2-3 point gap could be real, but 'significant' is not established. This is addressable by running multiple seeds and reporting mean/range, but as written the central empirical claim is statistically unverified.

Two other soft spots. First, the efficiency argument: the method is motivated as generating hard samples in one pass, but the main protocol still runs three evolution rounds to match the baselines. No wall-clock or cost comparison is reported, so 'efficient' is asserted, not demonstrated. Second, the multi-step tagging validation is only on math (Section 5.1). The general-domain and code results assume the same tagging quality holds, but that is not directly shown. The Section 5.5 diversity/difficulty discussion uses InsTag metrics that the method is designed to optimize, so that 'more diverse and challenging' claim is partly self-consistent; the downstream results do not depend on that metric, so this is a minor point.

For someone working on synthetic instruction data, this is worth a serious read. The tag-injection idea is a real advance over fixed-strategy evolution, and the analyses are mostly honest and informative. I would accept it for peer review, but I would make acceptance conditional on adding repeated-run evidence or at least softening the 'significantly' language, and on directly measuring the efficiency claim. Releasing code and data would make the work much easier to verify.

Referee Report

4 major / 5 minor

Summary. The paper proposes Tag-Evol, a data synthesis method that replaces hand-designed evolution strategies in Evol-Instruct with knowledge tags extracted from seed datasets. A multi-step tagging prompt builds domain-specific tag pools; evolution samples a batch of tags, asks the evolving LLM to select a budget-sized subset, and injects them into the original instruction in a single rewrite. Experiments compare Tag-Evol with Evol-Instruct and Auto Evol-Instruct on general, math, and code domains using Mistral-7B, Llama3-8B, and Qwen2.5-7B backbones, reporting consistently higher benchmark scores in Table 2. Additional analyses cover tagging-method ablation, data scale, model scale, leakage, and InsTag-based diversity/difficulty.

Significance. If the reported gains are reproducible, the contribution is practically useful: replacing monolithic evolution strategies with combinable knowledge tags is simple, requires minimal per-domain prompt engineering, and appears to give a few points on several benchmarks across three backbones. The paper is also careful to construct comparable baselines under an open-source setup and to include a leakage analysis. However, the main empirical claim rests on single runs without uncertainty quantification, and the efficiency and diversity claims are only partially supported, so the significance is currently conditional on additional verification.

major comments (4)

[§4.2, Table 2] The claim that Tag-Evol 'significantly outperforms' the baselines is not supported by the reported evidence: every condition in Table 2 appears to be a single SFT run, with no seeds, standard deviations, confidence intervals, or significance tests. Many per-task gaps are small (e.g., MT-Bench +0.1 or +0.2, ties on MATH under Mistral and on MBPP under Qwen2.5), and run-to-run variance in these benchmarks is commonly on the order of 1–2 points, comparable to the aggregate 2–3 point gap. Please provide repeated runs or error bars (or at least a significance test) for the main comparisons, or replace 'significantly' with a weaker claim.
[Abstract; §3.2; §4.1] The efficiency claim is not directly measured. The method is motivated by the cost of iterative evolution, but the main experiments use the same three-round setup and the same final data quantity as the baselines, and no wall-clock time, token counts, API cost, or number of LLM calls is reported. Section 5.5's InsTag difficulty metric is a proxy, not a cost measurement. Please add a direct efficiency comparison (e.g., generation cost per dataset or time to reach a fixed difficulty level) or restrict the claim to 'single-pass evolution enables controlled difficulty' without 'efficient' as a headline claim.
[§5.1, Figure 4] The multi-step tagging design is validated only on the math domain with Llama3-8B; there is no analogous ablation for the code or general-domain tag pools, even though the main results in Table 2 depend on those pools. If the code or Dolly tag pools are noisier or less specific, the cross-domain improvement claim would not generalize. Please report tagging ablations for at least the code domain, or provide tag-pool quality statistics (e.g., human-rated specificity, unique-aspect coverage) for all three domains.
[§5.5, Table 5] The diversity and difficulty analysis is partly self-consistent: Tag-Evol explicitly uses tag counts and tag sets as its evolution target, so evaluating the evolved data with InsTag's tag-count and tag-set metrics will tend to show higher values by construction. This does not independently establish that the data is more diverse or more challenging. Please complement Table 5 with an external measure (e.g., performance on a held-out distribution, human difficulty ratings, or embedding-based diversity) and discuss the circularity.

minor comments (5)

[Table 2] The table body contains garbled entries (e.g., '65.335.453.7' in the Mistral/Auto Evol-Ins row and '59.866.447.4' in the Llama3/Evol-Ins row) that appear to be missing spaces or line breaks; these should be corrected for readability.
[Figure 1; §5.3] There are several typos: 'Evol-Instrcut' in the Figure 1 caption and Section 1, and 'Tag-Instruct' and 'Tabel 3' in Section 5.3; these should be corrected.
[§3.2] The candidate tag batch size (the size of 'cand' in Equation 1) is never specified in the experimental setup, and no sensitivity analysis is provided for this hyperparameter or for the chosen difficulty budgets (1,3,5 for math; 3,5,7 for code); please report these values and, ideally, a small ablation.
[§5.4, Table 4] The n-gram leakage test is not very informative for the code benchmarks because most counts are 0 or 1; a sentence acknowledging the low sensitivity of this measure would help calibrate the reader's interpretation.
[Appendix B, Table 8] The prompt requires the model to output a tag subset of exactly budget size, but the paper does not state how malformed outputs (e.g., wrong subset size or unparseable format) are handled during data generation; please clarify whether such outputs are filtered, retried, or discarded.

Circularity Check

1 steps flagged · score 2.0 of 10

Secondary tag-count analysis in Section 5.5 is self-confirming, but the central downstream comparison on independent benchmarks is not circular.

self definitional [Section 5.5, Table 5 (Discussion of Complexity and Diversity)]
"Lu et al. (2023) use the average number of tags to indicate the difficulty of the dataset, and the full set of tags in the overall dataset to indicate diversity. We follow his setting and experiment using the prompt reported in the paper. ... The Tag-Evol evolved dataset has significant advantages in both difficulty and diversity."

The difficulty metric is the average number of tags per instruction and the diversity metric is the total distinct tag set, both measured by InsTag-style re-tagging. Tag-Evol's construction directly controls exactly these quantities: the evolution prompt requires the model to select a subset containing {Budget} tags (budgets 1,3,5 for math; 3,5,7 for code) and inject them into the instruction. Re-tagging the output therefore largely reports the number of tags the method was instructed to add, so the "more challenging and more diverse" conclusion in Section 5.5 is true by definition under this metric rather than by independent measurement. This circularity is limited to the analytic section; the main Table 2 results are evaluated on external downstream benchmarks.

full rationale

The paper's central claim is that SFT on Tag-Evol evolved data outperforms Evol-Instruct and Auto Evol-Instruct data on MT-Bench, IFEval, GSM8K, MATH-500, HumanEval, and MBPP. Those benchmarks are external to the tag-injection construction: no parameter is fitted to them, tag budgets are set by hand, and the method's only input from the seed data is the tag pool and the original instructions. No load-bearing self-citation appears, and no derived equation is reused as its own evidence in the main comparison. The only circular element is the secondary analysis in Section 5.5, where InsTag's difficulty (average tag count) and diversity (total tag count) metrics coincide with the exact quantities Tag-Evol is prompted to increase by construction, making the "more challenging and diverse data" claim self-consistent rather than independently demonstrated. Because the primary empirical claim rests on independent benchmarks, the overall circularity score is low (2).

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

The method introduces no new physical or formal entities; the tag pool is an annotation artifact rather than a postulated object. The central assumptions are about LLM reliability, the validity of tag-based difficulty proxies, and the transfer of tagging quality across domains.

free parameters (2)

difficulty budget b = math: 1, 3, 5; code: 3, 5, 7; general: not reported
The number of tags injected per round is chosen by hand per domain to create three difficulty levels; no sensitivity analysis is provided.
candidate tag batch size = not specified
The paper states a batch of candidate tags is sampled (Section 3.2) but does not report the batch size, which affects selection quality.

assumptions (4)

domain assumption LLMs can reliably select relevant tags and rewrite instructions without introducing errors
The whole tag injection pipeline (Section 3.2, Appendix B) depends on the evolution model executing Steps 1 to 4 correctly; the paper only mitigates hallucinations via a rewrite step and provides no failure-rate analysis.
domain assumption InsTag's tag-based difficulty and diversity metrics capture meaningful properties of instruction data
The analysis in Section 5.5 uses InsTag (Lu et al., 2023) to claim Tag-Evol produces more diverse and difficult data; this assumes the tag-count proxy is valid.
domain assumption The tag pool built from each seed dataset is representative and sufficient for that domain
Tag-Evol only uses tags extracted from the seed data (Section 3.1 and Limitations); if seeds are narrow, the evolution strategies are narrow. This is validated only for math in Section 5.1.
domain assumption Evaluation benchmarks are not contaminated by the evolved data
Section 5.4 tests 8/13-gram leakage and finds fewer matches than the seed, but longer paraphrase leakage is not checked.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Tag-Evol: Achieving Efficient Instruction Evolving via Tag Injection." pith.science (2026). https://pith.science/paper/ZMFNRWPN

@misc{pith2026250524165,
  author       = {Pith},
  title        = {Pith review of: Tag-Evol: Achieving Efficient Instruction Evolving via Tag Injection},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZMFNRWPN}},
  note         = {Machine review of arXiv:2505.24165}
}

read the original abstract

Evol-Instruct has made significant improvements as a data synthesis method in several areas. Existing methods typically rely on a fixed set of strategies to evolve, which require manual design and are monolithic in form. In addition, iterative evolution also makes the acquisition of hard samples expensive. In view of this, we propose the Tag-Evol framework, a more diverse and efficient instruction evolving method. Specifically, Tag-Evol uses diverse and specific knowledge tags as strategies to achieve controlled evolution by injecting different combinations of tags into the original instructions. Experiments with multiple backbones in diverse domain benchmarks show that the proposed method generates significantly better evolved data than other methods. Furthermore, we conduct a thorough analysis of the evolved data, demonstrating that Tag-Evol is not only efficient but also generates more diverse and challenging data.

Figures

Figures reproduced from arXiv: 2505.24165 by the authors.

**Figure 2.** An illustration of the proposed Tag-Evol framework. First, we utilize LLMs to tag seed datasets to [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** An illustration of the proposed multi-step [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (2 more)

**Figure 4.** Figure 4: Impact of different tagging methods on the [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

**Figure 5.** Figure 5: Multi-round performance at different data sizes using Llama3-8B as backbone. [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

33 extracted references · 3 canonical work pages

[1]

Marah Abdin, Jyoti Aneja, Hany Awadalla, Ahmed Awadallah, Ammar Ahmad Awan, Nguyen Bach, Amit Bahree, Arash Bakhtiari, Jianmin Bao, Harkirat Behl, et al. 2024. Phi-3 technical report: A highly capable language model locally on your phone. arXiv preprint arXiv:2404.14219

arXiv 2024
[2]

Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774

arXiv 2023
[3]

Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732

arXiv 2021
[4]

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

2023
[5]

Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

arXiv 2021
[6]

Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph E Gonzalez, et al. 2023. Vicuna: An open-source chatbot impressing gpt-4 with 90\ See https://vicuna. lmsys. org (accessed 14 April 2023), 2(3):6

2023
[7]

Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168

arXiv 2021
[8]

Mike Conover, Matt Hayes, Ankit Mathur, Jianwei Xie, Jun Wan, Sam Shah, Ali Ghodsi, Patrick Wendell, Matei Zaharia, and Reynold Xin. 2023. https://www.databricks.com/blog/2023/04/12/dolly-first-open-commercially-viable-instruction-tuned-llm Free dolly: Introducing the world's first truly open instruction-tuned llm

2023

Show all 33 references

[9]

Yuyang Ding, Xinyu Shi, Xiaobo Liang, Juntao Li, Qiaoming Zhu, and Min Zhang. 2024. Unleashing reasoning capability of llms via scalable question synthesis from scratch. arXiv preprint arXiv:2410.18693

2024 arXiv
[10]

Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Amy Yang, Angela Fan, et al. 2024. The llama 3 herd of models. arXiv preprint arXiv:2407.21783

2024 arXiv
[11]

Tingfeng Hui, Lulu Zhao, Guanting Dong, Yaqi Zhang, Hua Zhou, and Sen Su. 2024. Smaller language models are better instruction evolvers. arXiv preprint arXiv:2412.11231

2024 arXiv
[12]

Albert Q Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, et al. 2023. Mistral 7b. arXiv preprint arXiv:2310.06825

2023 arXiv
[13]

Hunter Lightman, Vineet Kosaraju, Yura Burda, Harri Edwards, Bowen Baker, Teddy Lee, Jan Leike, John Schulman, Ilya Sutskever, and Karl Cobbe. 2023. Let's verify step by step. arXiv preprint arXiv:2305.20050

2023 arXiv
[14]

Bingbin Liu, Sebastien Bubeck, Ronen Eldan, Janardhan Kulkarni, Yuanzhi Li, Anh Nguyen, Rachel Ward, and Yi Zhang. 2023 a . Tinygsm: achieving> 80\ arXiv preprint arXiv:2312.09241

2023 arXiv
[15]

Wei Liu, Weihao Zeng, Keqing He, Yong Jiang, and Junxian He. 2023 b . What makes good data for alignment? a comprehensive study of automatic data selection in instruction tuning. arXiv preprint arXiv:2312.15685

2023 arXiv
[16]

Keming Lu, Hongyi Yuan, Zheng Yuan, Runji Lin, Junyang Lin, Chuanqi Tan, Chang Zhou, and Jingren Zhou. 2023. \# instag: Instruction tagging for analyzing supervised fine-tuning of large language models. In The Twelfth International Conference on Learning Representations

2023
[17]

Haipeng Luo, Qingfeng Sun, Can Xu, Pu Zhao, Jianguang Lou, Chongyang Tao, Xiubo Geng, Qingwei Lin, Shifeng Chen, and Dongmei Zhang. 2023 a . Wizardmath: Empowering mathematical reasoning for large language models via reinforced evol-instruct. arXiv preprint arXiv:2308.09583

2023 arXiv
[18]

Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2023 b . Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568

2023 arXiv
[19]

Long Ouyang, Jeffrey Wu, Xu Jiang, Diogo Almeida, Carroll Wainwright, Pamela Mishkin, Chong Zhang, Sandhini Agarwal, Katarina Slama, Alex Ray, et al. 2022. Training language models to follow instructions with human feedback. Advances in neural information processing systems, 3...

2022
[20]

Zhen Tan, Dawei Li, Song Wang, Alimohammad Beigi, Bohan Jiang, Amrita Bhattacharjee, Mansooreh Karami, Jundong Li, Lu Cheng, and Huan Liu. 2024. Large language models for data annotation and synthesis: A survey. In Proceedings of the 2024 Conference on Empirical Methods in Nat...

2024
[21]

Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B Hashimoto. 2023. Alpaca: A strong, replicable instruction-following model. Stanford Center for Research on Foundation Models. https://crfm. stanford. edu/2023/03...

2023
[22]

Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2022. Self-instruct: Aligning language models with self-generated instructions. arXiv preprint arXiv:2212.10560

2022 arXiv
[23]

Yufei Wang, Wanjun Zhong, Liangyou Li, Fei Mi, Xingshan Zeng, Wenyong Huang, Lifeng Shang, Xin Jiang, and Qun Liu. 2023. Aligning large language models with human: A survey. arXiv preprint arXiv:2307.12966

2023 arXiv
[24]

Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. 2023. Wizardlm: Empowering large language models to follow complex instructions. arXiv preprint arXiv:2304.12244

2023 arXiv
[25]

Zhangchen Xu, Fengqing Jiang, Luyao Niu, Yuntian Deng, Radha Poovendran, Yejin Choi, and Bill Yuchen Lin. 2024. Magpie: Alignment data synthesis from scratch by prompting aligned llms with nothing. arXiv preprint arXiv:2406.08464

2024 arXiv
[26]

An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Haoran Wei, et al. 2024. Qwen2. 5 technical report. arXiv preprint arXiv:2412.15115

2024 arXiv
[27]

Weihao Zeng, Can Xu, Yingxiu Zhao, Jian-Guang Lou, and Weizhu Chen. 2024. Automatic instruction evolving for large language models. arXiv preprint arXiv:2406.00770

2024 arXiv
[28]

Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. 2023. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems, 36:46595--46623

2023
[29]

Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. 2024. Judging llm-as-a-judge with mt-bench and chatbot arena. Advances in Neural Information Processing Systems, 36

2024
[30]

Chunting Zhou, Pengfei Liu, Puxin Xu, Srinivasan Iyer, Jiao Sun, Yuning Mao, Xuezhe Ma, Avia Efrat, Ping Yu, Lili Yu, et al. 2024. Lima: Less is more for alignment. Advances in Neural Information Processing Systems, 36

2024
[31]

Jeffrey Zhou, Tianjian Lu, Swaroop Mishra, Siddhartha Brahma, Sujoy Basu, Yi Luan, Denny Zhou, and Le Hou. 2023. Instruction-following evaluation for large language models. arXiv preprint arXiv:2311.07911

2023 arXiv
[32]

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...
[33]

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 7, 2026 · model on record in the stance chip above.

[1] [1]

Marah Abdin, Jyoti Aneja, Hany Awadalla, Ahmed Awadallah, Ammar Ahmad Awan, Nguyen Bach, Amit Bahree, Arash Bakhtiari, Jianmin Bao, Harkirat Behl, et al. 2024. Phi-3 technical report: A highly capable language model locally on your phone. arXiv preprint arXiv:2404.14219

arXiv 2024

[2] [2]

Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774

arXiv 2023

[3] [3]

Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models. arXiv preprint arXiv:2108.07732

arXiv 2021

[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 Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374

arXiv 2021

[6] [6]

Wei-Lin Chiang, Zhuohan Li, Zi Lin, Ying Sheng, Zhanghao Wu, Hao Zhang, Lianmin Zheng, Siyuan Zhuang, Yonghao Zhuang, Joseph E Gonzalez, et al. 2023. Vicuna: An open-source chatbot impressing gpt-4 with 90\ See https://vicuna. lmsys. org (accessed 14 April 2023), 2(3):6

2023

[7] [7]

Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, et al. 2021. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168

arXiv 2021

[8] [8]

Mike Conover, Matt Hayes, Ankit Mathur, Jianwei Xie, Jun Wan, Sam Shah, Ali Ghodsi, Patrick Wendell, Matei Zaharia, and Reynold Xin. 2023. https://www.databricks.com/blog/2023/04/12/dolly-first-open-commercially-viable-instruction-tuned-llm Free dolly: Introducing the world's first truly open instruction-tuned llm

2023