Pith. sign in

REVIEW 5 major objections 5 minor 21 references

Infinite-Instruct: Synthesizing Scaling Code instruction Data with Bidirectional Synthesis and Static Verification

T0 review · 5 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 claims that a bidirectional synthesis pipeline with static filters makes 180K code instructions rival ten-times-larger training sets.

desk verdict The pipeline is interesting and the released datasets are a real resource, but the headline improvement numbers do not reproduce from the paper's own tables, and the abstract/conclusion disagreement is load-bearing. read the letter →

arxiv 2505.23177 v1 pith:XFKYLJCG submitted 2025-05-29 cs.CL

Wenjing Xing , Wenke Lu , Yeheng Duan , Bing Zhao , Zhenghui kang , Yaolong Wang , Kai Gao , Lei Qiao This is my paper
classification cs.CL
keywords codeinstructiondatasynthesisReverseConstructionBackfeedingknowledgegraphstaticanalysistuninggenerationbenchmarksQwen2.5-Coder
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

This paper argues that high-quality code instruction data does not have to be hand-written or evolved from prompts: it can be manufactured from code snippets and keyword vocabularies. The proposed pipeline, Infinite-Instruct, runs two complementary passes—Reverse Construction turns real code snippets into programming problems, and Backfeeding Construction recombines task, instruction, and knowledge-point keywords through a knowledge graph into harder problems—then grades the prompts on seven dimensions and deletes any prompt-response pair whose generated code fails a language-specific linter. On Qwen2.5-Coder bases, the authors report average benchmark gains of 21.70% (7B) and 36.95% (32B) over the OSS-Instruct baseline, and they report matching or beating the official Qwen2.5-Coder-Instruct on several benchmarks while using less than one-tenth of its instruction data. The significance, if the numbers hold, is that the bottleneck in code instruction tuning moves from data acquisition to data filtering.

What carries the argument

The load-bearing mechanism is the closed loop between code and problems: 'Code → Problem' (Reverse Construction) generates diverse prompts from code snippets, and 'Keyword → Problem' (Backfeeding Construction) rebuilds prompts from knowledge-graph-triple keyword combinations. The knowledge graph is a structured vocabulary of task, instruction, and knowledge-point nodes connected by typed relations such as 'requires,' 'contains,' and 'displays,' which is used to assemble keyword groups with clear semantic association before the LLM writes each problem. Static analysis is the hard gate: per-language linters (PyLint, ESLint, Checkstyle, Clang-Tidy, SQLFluff) run on the generated responses, and any error-level finding removes the whole prompt-response pair; this filtering is what the attribution experiments credit for most of the improvement.

What would settle it

A reader can settle the central claim by recomputing Table 4's average improvement percentages directly from Tables 2 and 3 using the same relative-gain formula applied to individual rows; the published rows are 21.70% (7B Rev+Back 180K) and 36.95% (32B Backfeed 90K), and a standard mean of the seven per-benchmark gains does not reproduce them. A second check is to count the released datasets: the pipeline description reports roughly 30K reverse and 20K backfeed problems, while the experiments name Reverse-100K and Backfeed-100K, so the sizes should be audited against the released files.

Watch

Extended reading notes

Core claim

The central claim is that a bidirectional synthesis loop produces code instruction data whose quality matches or exceeds data that costs an order of magnitude more to collect. Reverse Construction samples 5–20 line code snippets from a seed corpus and asks an LLM to design realistic problems for them, with six rewriting directions (constraints, depth, concretization, reasoning, input, innovation) and a sentence-restructuring pass to diversify phrasing. Backfeeding Construction extracts three keyword types—tasks, instructions, and knowledge points—from those problems, links them as typed graph triples, and recombines logically coherent keyword groups into seven kinds of problems (generation, understanding, knowledge questions, completion, optimization, debug, modification). The output is then scored three times on seven Arena-Hard-Auto dimensions, filtered to a score of at least 6, and passed through language-specific static analyzers that delete any pair containing error-level syntax issues. With roughly 200K samples before filtering (180K after), the strongest 7B model surpasses the official Qwen2.5-Coder-7B-Instruct on MBPP+, BigCodeBench, LiveCodeBench, and Arena Hard, and several 32B variants beat the official instruct model on BigCodeBench and LiveCodeBench.

Load-bearing premise

The load-bearing premise is that the paper's headline average-gain percentages are correctly computed from its own benchmark tables; a standard re-averaging of the per-benchmark gains gives 21.65% for the 7B combined model rather than the stated 21.70%, and the 32B headline changes from 36.95% in the abstract to 34.95% in the conclusion, so those summary statistics are not reproducible from the reported data as written.

Editorial extensions

If this is right

  • If the reported gains replicate, a 180K-sample synthetic set is sufficient to move a 7B code model from the OSS-Instruct baseline to near the level of a model tuned on millions of samples, reducing the data cost of code SFT by roughly an order of magnitude.
  • The static-analysis filter is the highest-leverage single step in the pipeline: on the 7B model, Backfeed 90K improves over its unfiltered Backfeed 100K version by 10.55 points of average gain (19.30% vs 8.75%), so parser-grade checks should become a standard first filter for synthetic code data.
  • Because Reverse and Backfeed produce different difficulty profiles (median 6.0 and 8.0 on a 1–10 scale), dataset mixing ratios become a training knob: combining them reduces benchmark volatility and gives the best 7B result.
  • The pipeline can continue generating new problems by cycling code fragments and maintained keyword vocabularies, which is the scalability the authors claim for the framework.

Reading between the lines

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

  • Beyond the paper, the natural next test is an apples-to-apples ablation: train the same base model on OSS-Instruct-75K-GPT-4o, Reverse-90K, and Backfeed-90K with identical recipe and response generator, so the improvement is attributable to prompt construction and filtering rather than to newer GPT-4o responses used in the synthetic sets.
  • A second extension would replace the GPT-4o grader with human or execution-based validation on a subsample, because the seven quality scores and the complexity scores are LLM judgments and may partly reflect grader taste.
  • The static analyzers are syntax-only, so the data still contains logical and algorithmic errors; execution-based checks such as unit tests or runtime assertions are the obvious next lever, and the authors explicitly list dynamic analysis as future work.
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

5 major / 5 minor

Summary. The paper proposes Infinite-Instruct, a pipeline that (i) reverse-constructs coding problems from code snippets, (ii) backfeeds keyword combinations organized with a knowledge graph to generate additional problems, (iii) filters prompts using GPT-4o multi-criteria scoring, and (iv) filters generated responses with language-specific static analysis tools. The authors fine-tune Qwen2.5-Coder-7B-Base and Qwen2.5-Coder-32B-Base on the resulting datasets and report gains over Magicoder-OSS-Instruct-75K, claiming average improvements of 21.70% on 7B and 36.95% on 32B, as well as parity with Qwen2.5-Coder-Instruct using less than one-tenth of the instruction data.

Significance. If the headline claims held, the paper would offer a practical, scalable recipe for code instruction-data synthesis, with the additional merit of open-sourcing the datasets and giving detailed prompt templates. The external benchmark evaluations (HumanEval, MBPP, MBPP+, BigCodeBench, LiveCodeBench, Arena Hard) provide a non-circular check of the method's effect, and the static-analysis filtering is a sensible and concrete quality-control component. However, the central quantitative claims are not reproducible from the paper's own tables, and the abstract/conclusion and dataset-size statements conflict. Until these load-bearing discrepancies are resolved, the significance of the contribution cannot be assessed.

major comments (5)
  1. [§4.2.1, Tables 2-4] The headline average improvements are not reproducible under any averaging formula stated in the paper. For Rev+Back 180K on the 7B model, which Table 4 reports as 21.70%, the arithmetic mean of the seven per-benchmark percentage gains over OSS-75K is approximately 72.2%, dominated by Arena Hard (+453%); excluding Arena Hard gives approximately 8.7%; and the sum of raw-score gains divided by the baseline sum gives approximately 19.6%. For Backfeed 90K on the 32B model, reported as 36.95%, the same three calculations give approximately 47.7%, 14.9%, and 23.2%. Since no formula in §4.2 recovers the reported values, the paper's central claim is unsupported by the presented experimental record.
  2. [Abstract vs. Conclusion] The abstract reports an average improvement of 36.95% on 32B-parameter models, while the conclusion reports 34.95%. In Table 4, these are the values for Backfeed 90K and Rev+Back 180K, respectively. The paper never states which configuration the abstract headline refers to, and the two numbers cannot both be the headline result; this ambiguity must be resolved.
  3. [§3.1-3.3 vs. §4.1] Dataset sizes are internally inconsistent. Section 3 states that roughly 30K reverse and 20K backfeed prompts are synthesized, and then that 10K reverse and 10K backfeed data are filtered out. Section 4, however, trains on Reverse-100K/Reverse-90K and Backfeed-100K/Backfeed-90K, as well as Rev+Back 200K and Rev+Back 180K. These quantities cannot all be correct. The 'less than one-tenth of the instruction fine-tuning data' claim and all per-dataset comparisons depend on these sizes, so this is not a cosmetic typo.
  4. [§3.3, A.7] The prompt-filtering protocol is not reproducible from the appendix. Section 3.3 describes a 0-10 score averaged over three assessments with a threshold of 6, but the actual prompt in A.7 asks for a list of 'Standards Met' and never elicits a numerical score. The mapping from the seven criteria to the scalar score, and therefore the filtering decision, is unspecified.
  5. [§3.4 vs. §3.1-3.2] The response-filtering statistics are inconsistent with the earlier generation counts. Section 3.4 says that approximately 10,000 out of 100,000 generated responses contained syntax issues, while Sections 3.1 and 3.2 report only about 50K synthesized prompts in total. Either the generation scale or the filtering description is wrong, and this affects the claimed cost and yield of the pipeline.
minor comments (5)
  1. [Figure 4] The figure caption reads 'Benchmark with MHPP,' but the text and Table 2 refer to MBPP+; this is likely a typo.
  2. [§4.2.2] The claim that Qwen2.5-Coder-Instruct was trained on 'millions of high-quality prompts' is taken from the Qwen technical report; a direct comparison under the same evaluation harness would strengthen the efficiency claim, since the official numbers may use different inference or post-processing settings.
  3. [Conclusion] The conclusion attributes the MBPP improvement from 74.80% to 77.80% to static analysis, but Table 2 shows that the 77.80 result belongs to Rev+Back 180K, i.e., the combined filtered dataset; the sentence conflates the combined strategy with static filtering alone.
  4. [§4.2.2] There is a typo, 'fune-tuned' for 'fine-tuned,' and the dataset name 'Magicoder-OSS-Instruct-75K-GPT-4o' is used inconsistently with the shorter name 'OSS-75K-GPT-4o' in the tables.
  5. [§3.3] The sentence 'Finally, we filter out 10K reverse data and 10K backfeed data' is ambiguous: it is unclear whether 10K samples are removed, leaving 20K reverse and 10K backfeed, or whether 10K are retained from each source.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claims are benchmarked externally and the synthesis pipeline is not defined in terms of its own outputs.

full rationale

The paper's derivation chain is: synthesize instruction data via Reverse and Backfeeding construction (using GPT-4o as a generator), filter responses with external static-analysis tools, fine-tune Qwen2.5-Coder base models, and measure on external benchmarks (HumanEval, MBPP, MBPP+, Aider, BigCodeBench, LiveCodeBench, Arena Hard). No equation in the paper defines the reported benchmark improvements in terms of the synthesized data or the filtering scores; the improvements are empirical outcomes on held-out external benchmarks. The use of GPT-4o to generate and then score/filter prompts is a self-referential quality-control loop, but it is not a circular derivation: the fine-tuning evaluation is external, and the static-analysis filtering is performed by independent linters rather than by the model being evaluated. There are no load-bearing self-citations; references to OSS-Instruct, Qwen2.5-Coder, and Arena-Hard are standard external prior work. The noted discrepancies in the average-improvement percentages (e.g., 36.95% vs 34.95% on 32B) and in dataset sizes (Section 3 roughly 30K+20K vs Section 4 Reverse-100K/Backfeed-100K) are internal-consistency and correctness concerns, not circularity: they do not make any claimed result true by construction. Therefore the appropriate circularity score is 0.

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

No new particles, forces, or formal entities are introduced. The pipeline's assumptions are about LLM reliability, evaluator calibration, and linter coverage, listed above.

free parameters (3)
  • quality_filter_threshold = 6.0
    Section 3.3: 'We filter out data with scores less than 6 points.' Hand-chosen cutoff for GPT-4o quality scores; affects which prompts are retained.
  • cosine_similarity_threshold = 0.8
    Section 3.2: 'We deduplicate the final keyword groups using cosine similarity (threshold 0.8).' Hand-chosen threshold for keyword-group deduplication.
  • code_snippet_line_range = 5-20
    Section 3.1: 'randomly extract code snippets of 5-20 lines multiple times.' Hand-selected range for seed snippets; influences problem diversity and complexity.
assumptions (4)
  • domain assumption GPT-4o (versions 0806 and 0816) can generate valid programming problems from code snippets and keyword combinations, and can produce correct code responses.
    Sections 3.1, 3.2, and 3.4 rely on GPT-4o for all generation and response synthesis; the success of the pipeline depends on this capability.
  • domain assumption GPT-4o's self-assessed scores on the seven Arena-Hard criteria are a reliable indicator of instruction quality.
    Section 3.3 uses the average of three GPT-4o evaluations with a cutoff of 6 to filter prompts; this assumes the evaluator is well-calibrated.
  • domain assumption Static analysis with error-level linter rules is sufficient to ensure generated code is acceptable for SFT training.
    Section 3.4 removes only error-level linter failures; logical and semantic errors are not caught, as the Limitations section acknowledges.
  • domain assumption The OSS-75K and OSS-75K-GPT-4o baselines are appropriate controls for isolating the benefit of the new construction methods.
    Tables 2 and 3 compare against these baselines, assuming they represent the previous state of the art for this data recipe.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Infinite-Instruct: Synthesizing Scaling Code instruction Data with Bidirectional Synthesis and Static Verification." pith.science (2026). https://pith.science/paper/XFKYLJCG

@misc{pith2026250523177,
  author       = {Pith},
  title        = {Pith review of: Infinite-Instruct: Synthesizing Scaling Code instruction Data with Bidirectional Synthesis and Static Verification},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/XFKYLJCG}},
  note         = {Machine review of arXiv:2505.23177}
}
read the original abstract

Traditional code instruction data synthesis methods suffer from limited diversity and poor logic. We introduce Infinite-Instruct, an automated framework for synthesizing high-quality question-answer pairs, designed to enhance the code generation capabilities of large language models (LLMs). The framework focuses on improving the internal logic of synthesized problems and the quality of synthesized code. First, "Reverse Construction" transforms code snippets into diverse programming problems. Then, through "Backfeeding Construction," keywords in programming problems are structured into a knowledge graph to reconstruct them into programming problems with stronger internal logic. Finally, a cross-lingual static code analysis pipeline filters invalid samples to ensure data quality. Experiments show that on mainstream code generation benchmarks, our fine-tuned models achieve an average performance improvement of 21.70% on 7B-parameter models and 36.95% on 32B-parameter models. Using less than one-tenth of the instruction fine-tuning data, we achieved performance comparable to the Qwen-2.5-Coder-Instruct. Infinite-Instruct provides a scalable solution for LLM training in programming. We open-source the datasets used in the experiments, including both unfiltered versions and filtered versions via static analysis. The data are available at https://github.com/xingwenjing417/Infinite-Instruct-dataset

Figures

Figures reproduced from arXiv: 2505.23177 by the authors.

Figure 1
Figure 1. Automated Prompt Synthesis Technology Roadmap. [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. Complexity Score Comparison 10,000 out of 100,000 generated responses con￾tained syntax issues, including incorrect indenta￾tion, non-code content mixed within code blocks, and erroneous class instantiation methods (detailed cases are provided in Appendix B). 4 Experiments 4.1 Experimental Settings We select Qwen2.5-Coder-7B-Base and Qwen2.5- Coder-32B-Base models as baseline to investigate the effectiveness of our … view at source ↗
Figure 3
Figure 3. Benchmark with MBPP MBPP and MBPP+ evaluation datasets, data that has undergone static syntax checking tends to achieve higher scores than data that has not been checked. The specific performance improvement effects can be referred to in [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (1 more)
Figure 5
Figure 5. Figure 5: Percentage of topic types Quality Improvement. Magicoder-OSS￾Instruct-75K-GPT-4o, shows improvements over the original Magicoder-OSS-Instruct-75K dataset in most benchmarks. It indicates that as the per￾formance of the LLM used to generate responses improves, the quali…

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

21 extracted references · 2 canonical work pages

  1. [1]

    Bo Adler, Niket Agarwal, Ashwath Aithal, Dong H Anh, Pallab Bhattacharya, Annika Brundyn, Jared Casper, Bryan Catanzaro, Sharon Clay, Jonathan Cohen, and 1 others. 2024. https://arxiv.org/abs/2406.11704 Nemotron-4 340b technical report . Computing Research Repository, arXiv:2406.11704

    arXiv 2024

  2. [2]

    Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, and 1 others. 2021. Program synthesis with large language models. Computing Research Repository, arXiv:2108.07732

    arXiv 2021

  3. [3]

    Federico Cassano, John Gouwar, Daniel Nguyen, Sydney Nguyen, Luna Phipps-Costin, Donald Pinckney, Ming-Ho Yee, Yangtian Zi, Carolyn Jane Anderson, Molly Q Feldman, and 1 others. 2023. Multipl-e: a scalable and polyglot approach to benchmarking neural code generation. IEEE Transactions on Software Engineering, 49(7):3675--3691

    2023

  4. [4]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, and 1 others. 2021. https://arxiv.org/abs/2107.03374 Evaluating large language models trained on code . Computing Research Repository, arXiv:2107.03374

    arXiv 2021

  5. [5]

    Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, Amy Yang, Angela Fan, Anirudh Goyal, Anthony Hartshorn, Aobo Yang, Archi Mitra, Archie Sravankumar, Artem Korenev, Arthur Hinsvark, and 542 others. 2024. https://arxiv.org/abs/2407.21783 The llama 3...

    arXiv 2024

  6. [6]

    Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Keming Lu, Kai Dang, Yang Fan, Yichang Zhang, An Yang, Rui Men, Fei Huang, Bo Zheng, Yibo Miao, Shanghaoran Quan, and 5 others. 2024. https://arxiv.org/abs/2409.12186 Qwen2.5-coder technical report . Computing Research Repository, arXiv:2409.12186

    arXiv 2024

  7. [7]

    Naman Jain, King Han, Alex Gu, Wen-Ding Li, Fanjia Yan, Tianjun Zhang, Sida Wang, Armando Solar-Lezama, Koushik Sen, and Ion Stoica. 2024. Livecodebench: Holistic and contamination free evaluation of large language models for code. Computing Research Repository, arXiv:2403.07974

    arXiv 2024

  8. [8]

    Tianle Li, Wei-Lin Chiang, Evan Frick, Lisa Dunlap, Tianhao Wu, Banghua Zhu, Joseph E Gonzalez, and Ion Stoica. 2024. From crowdsourced data to high-quality benchmarks: Arena-hard and benchbuilder pipeline. Computing Research Repository, arXiv:2406.11939

    arXiv 2024

Show all 21 references
  1. [9]

    Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, and Lingming Zhang. 2023. Is your code generated by chatgpt really correct? rigorous evaluation of large language models for code generation. Advances in Neural Information Processing Systems, 36:21558--21572

    2023

  2. [10]

    Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2023. https://arxiv.org/abs/2306.08568 Wizardcoder: Empowering code large language models with evol-instruct . Computing Research Repository, arXiv:2306.08568

    2023 arXiv

  3. [11]

    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

    2023

  4. [12]

    Ke Wang, Jiahui Zhu, Minjie Ren, Zeming Liu, Shiwei Li, Zongye Zhang, Chenkai Zhang, Xiaoyu Wu, Qiqi Zhan, Qingjie Liu, and 1 others. 2024. https://arxiv.org/abs/2410.12896 A survey on data synthesis and augmentation for large language models . Computing Research Repository, a...

    2024 arXiv

  5. [14]

    Smith, Daniel Khashabi, and Hannaneh Hajishirzi

    Yizhong Wang, Yeganeh Kordi, Swaroop Mishra, Alisa Liu, Noah A. Smith, Daniel Khashabi, and Hannaneh Hajishirzi. 2023. https://arxiv.org/abs/2212.10560 Self-instruct: Aligning language models with self-generated instructions . Computing Research Repository, arXiv:2212.10560

    2023 arXiv

  6. [15]

    Yuxiang Wei, Zhe Wang, Jiawei Liu, Yifeng Ding, and Lingming Zhang. 2023. Magicoder: Empowering code generation with oss-instruct. Computing Research Repository, arXiv:2312.02120

    2023 arXiv

  7. [16]

    Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. 2023. https://arxiv.org/abs/2304.12244 Wizardlm: Empowering large language models to follow complex instructions . Computing Research Repository, arXiv:2304.12244

    2023 arXiv

  8. [17]

    Yue Yu, Yuchen Zhuang, Jieyu Zhang, Yu Meng, Alexander J Ratner, Ranjay Krishna, Jiaming Shen, and Chao Zhang. 2023. https://proceedings.neurips.cc/paper_files/paper/2023/hash/6ce3d330be09e35ffdfc7a4cc29b5e2a-Abstract-Conference.html Large language model as attributed training...

    2023

  9. [18]

    Shengyu Zhang, Linfeng Dong, Xiaoya Li, Sen Zhang, Xiaofei Sun, Shuhe Wang, Jiwei Li, Runyi Hu, Tianwei Zhang, Fei Wu, and 1 others. 2023. https://arxiv.org/abs/2308.10792 Instruction tuning for large language models: A survey . Computing Research Repository, arXiv:2308.10792

    2023

  10. [19]

    Terry Yue Zhuo, Minh Chien Vu, Jenny Chim, Han Hu, Wenhao Yu, Ratnadira Widyasari, Imam Nur Bani Yusuf, Haolan Zhan, Junda He, Indraneil Paul, and 1 others. 2024. Bigcodebench: Benchmarking code generation with diverse function calls and complex instructions. Computing Researc...

    2024 arXiv

  11. [20]

    Yongqiang Zou, Xing Jin, Yi Li, Zhimao Guo, Eryu Wang, and Bin Xiao. 2014. Mariana: tencent deep learning platform and its applications. Proc. VLDB Endow., 7(13)

    2014

  12. [21]

    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...

  13. [22]

    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.