Pith. sign in

REVIEW 5 major objections 5 minor 56 references

MGS3: A Multi-Granularity Self-Supervised Code Search Framework

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 This paper argues that training code search on comment-code alignments at statement, block, and function levels lifts retrieval at every granularity, and supports the claim with a 536K-pair dataset and consistent gains on four pre-trained…

desk verdict New dataset and framework for multi-granularity code search with consistent gains; the main open question is whether the comment-code alignment heuristic is reliable. read the letter →

arxiv 2505.24274 v1 pith:6WKQ3XBR submitted 2025-05-30 cs.SE cs.IR

Rui Li , Junfeng Kang , Qi Liu , Liyang He , Zheng Zhang , Yunhao Sha , Linbo Zhu , Zhenya Huang This is my paper
classification cs.SEcs.IR
keywords codesearchmulti-granularitycontrastivelearningself-supervisedabstractsyntaxtreerepresentationMGCodeNetinformationretrieval
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 code search models are leaving abundant supervision unused: prior self-supervised training aligns natural-language docstrings only with whole functions, while the two finer levels of code inside those functions are ignored. The authors extract inline comments paired with control-flow blocks and trailing comments paired with single statements, assembling 536K+ query-code pairs across six programming languages into a dataset called MGCodeSearchNet. On top of it they train MGS3, a contrastive framework whose representation module aggregates statement-level embeddings up the abstract syntax tree, whose positive-sample selection uses a MaxSim operator to handle one-comment-to-many-blocks ambiguity, and whose negative set includes harder same-function snippets at fine granularities. Applied to four pre-trained code models, the framework improves Mean Reciprocal Rank on all zero-shot and fine-tuned benchmarks tested, which is the paper's central claim: multi-granularity alignment is a data-efficient, model-agnostic upgrade for code search.

What carries the argument

Three components carry the argument. The Hierarchical Multi-Granularity Representation module (HMGR) treats statement-level snippets as the smallest unit, encodes the whole function in one pass, and builds any coarser snippet's embedding by aggregating its AST children's embeddings through a learned weighted mean with LayerNorm, so structural nesting flows into the representation. The MaxSim operator, borrowed from late-interaction passage retrieval, resolves ambiguous alignments by treating all candidate blocks for one comment as positives and taking the maximum similarity in the loss. In-function negative samples add same-granularity snippets from within the same function, excluding nested siblings, as harder negatives than in-batch samples from other functions. The three granularities are combined in a single objective $\mathcal{L}_{MG} = \mathcal{L}_f + \alpha\mathcal{L}_b + \beta\mathcal{L}_s$ with $\alpha = 1$ and $\beta = 0.6$, and HMGR is computed offline for code, so the framework adds no online latency.

What would settle it

Human-annotate a random sample of a few hundred MGCodeSearchNet pairs and measure how often the aligned comment truly describes the paired snippet, then retrain MGS3 with the same data but the comment-to-snippet pairings randomly shuffled within each function; if retrieval scores stay at the same level after shuffling, the specific alignment signal is not what carries the gain.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is that the supervision needed to search code at multiple granularities already exists inside ordinary functions as inline and trailing comments, and that a framework which extracts and uses it improves retrieval everywhere. MGS3 encodes the whole function, extracts per-statement token representations, and aggregates them up the abstract syntax tree to form block- and function-level representations, a module the authors call HMGR. The training objective is the sum of three InfoNCE losses, one per granularity: at block level, a one-to-many comment-to-block alignment is resolved by the MaxSim operator, which scores every candidate block and keeps the best match; at block and statement level, the negative set is extended with same-granularity snippets from inside the same function. The paper reports that applying this recipe raises Mean Reciprocal Rank on all seven zero-shot benchmarks and all thirteen fine-tuned benchmark configurations, for every backbone model tested.

Load-bearing premise

The whole pipeline rests on the heuristic that an inline comment describes the code block that follows it and a trailing comment describes the statement on its own line; if real-world comments frequently violate that convention, the training pairs are noisy and the reported gains may come from other components.

Editorial extensions

If this is right

  • Any pre-trained code encoder can be upgraded with this training recipe; the paper demonstrates gains on four different backbone models in both zero-shot and fine-tuned settings.
  • Fine-grained code search becomes trainable without hand-annotated parallel data, because the comment-code pairs are mined from ordinary repository code by parsing.
  • Models trained this way adapt more quickly where downstream data is scarce; the paper highlights the largest relative fine-tuning gains on CoNaLa, the smallest training set.
  • Block- and statement-level supervision transfers to function-level search, so fine-grained signals can be leveraged even when the deployed task is whole-function retrieval.

Reading between the lines

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

  • If real-world comments frequently violate the alignment heuristic, MaxSim may systematically pick the easiest-to-match candidate block rather than the semantically correct one; a human audit of a few hundred pairs would reveal how much of the block-level gain is genuine.
  • The same recipe of hierarchy-guided aggregation plus in-function hard negatives could transfer to other nested retrieval domains, such as SQL subqueries, configuration blocks, or notebook cells, where aligned training pairs are currently scarce.
  • Because HMGR representation building is offline, the framework slots naturally into retrieval-augmented generation pipelines, flagged in the paper as future work, where a single function could be retrieved at the granularity the generated context actually needs.
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 MGS3, a multi-granularity self-supervised code search framework. It first constructs MGCodeSearchNet, a dataset of over 536K natural-language/code pairs at function, block, and statement levels, derived from CodeSearchNet via heuristic comment-to-code alignment. Then it introduces a Hierarchical Multi-Granularity Representation (HMGR) module that aggregates AST-guided statement-level embeddings into block- and function-level representations, and a contrastive learning objective combining function-, block-, and statement-level InfoNCE losses with MaxSim positive selection and in-function negative samples. Experiments on four pre-trained backbones (CodeBERT, GraphCodeBERT, UniXcoder, CodeT5+) and eight benchmarks covering three granularities report consistent MRR improvements in both zero-shot and fine-tuning settings, with ablations showing that removing any component degrades performance.

Significance. If the reported results hold, MGS3 would be a valuable and practical contribution: it shows that fine-grained comment-code alignment can be mined from repositories at scale and used to improve code retrieval across granularities, in a model-agnostic way. The paper ships a new dataset and code, reports experiments across four backbones and eight benchmarks, and includes ablations that individually assess the proposed modules. The central claim is an empirical performance improvement, not a circular theoretical derivation, and the gains are large and consistent. However, the two load-bearing pillars—the quality of the heuristic alignment that generates the fine-grained supervision, and the rigor of the experimental comparisons—need strengthening before the contribution is fully established.

major comments (5)
  1. [Section 3.1] The heuristic alignment that generates the block-level and statement-level pairs is not validated. The paper itself states that the inline-comment heuristic 'has a flaw that can lead to ambiguous alignment information,' and trailing comments are aligned to the current line with no stated validation. Since the 197K block-level and 258K statement-level pairs are the source of the paper's novel multi-granularity supervision, the correctness of these alignments is load-bearing. Please provide quantitative evidence of alignment quality, for example a human evaluation on a random sample, or a control experiment in which the fine-grained pairs are replaced by randomly paired comments and code snippets of the same granularity while keeping the loss structure identical. Such an experiment would show that the observed gains come from the semantic content of the alignments rather than from the additional contrastive training data alone.
  2. [Section 6.3, Table 2 and Table 3] The paper claims that 'All experiments meet the p<0.01 significance threshold' but provides no test description, no test statistic, no degrees of freedom, and no standard deviations. The main tables report only averages over three seeds. Please report mean ± standard deviation for each entry, and specify the significance test (e.g., paired bootstrap or paired t-test across benchmark instances, or across seeds) together with the exact null hypothesis. As written, the significance claim is unverifiable.
  3. [Section 6.3 and Appendix D.3] The hyperparameters α and β, as well as the temperature τ, learning rate, and number of epochs, appear to be selected using the evaluation benchmarks themselves. Section D.3 states that sensitivity experiments for α and β were conducted 'using the CodeBERT model on Adv, StaQC, and CoNaLa,' which are the test sets used in Tables 2 and 3. Selecting hyperparameters on the test benchmarks, rather than on a held-out validation set, can inflate the reported improvements and weakens the claim that the method generalizes. Please move hyperparameter selection to validation splits and report the test performance with fixed hyperparameters.
  4. [Section 6.4, Table 2] The 'Original' zero-shot results for CodeBERT, GraphCodeBERT, and UniXcoder are taken from previous papers, while the 'w/ MGS3' results are produced by the authors' pipeline. Differences in candidate pool construction, query preprocessing, tokenization, or MRR computation can strongly affect the numbers, especially when the original MRR values are near zero (e.g., CodeBERT on Adv, CoSQA, XLCoST-FL). Please re-evaluate the original released checkpoints of all four backbones using the exact evaluation code and candidate sets used for the w/ MGS3 setting, and report both sets of numbers under identical conditions.
  5. [Section 3.1 and Section 6.4] Since MGCodeSearchNet is constructed from the CodeSearchNet corpus, the paper should explicitly discuss and rule out overlap between the CodeSearchNet training split and the code pools used in the zero-shot evaluation benchmarks (CoSQA, Adv, XLCoST, SO-DS, StaQC, CoNaLa). If any of these benchmarks draw code from the same GitHub repositories as CodeSearchNet, the zero-shot improvements could be inflated by pre-training on near-duplicate code. Please quantify the degree of repository or file-level overlap, or state clearly that no overlap exists based on the benchmarks' construction.
minor comments (5)
  1. [Abstract] The abstract contains a typographical error: 'MGS$^{3}$}' has an unmatched closing brace; please correct the notation.
  2. [Throughout] The framework name is rendered inconsistently as MGS3, MGS$^3$, and MGS3 in different places; please unify the notation.
  3. [Section 5.2, Eq. (5)] The definition of the AST subtree T for a code snippet is informal. Please clarify which nodes are retained (e.g., statement and block nodes only) and how the 'parent' relation is defined for non-statement intermediates.
  4. [Section 6.5] For the fine-tuning experiments, it is unclear whether the same fine-tuning hyperparameters (learning rate, epochs, batch size) are used for the 'Fine-tuning' and 'w/ MGS3' conditions. Please state the fine-tuning protocol for both conditions.
  5. [Table 8] In the sensitivity experiments, α and β are varied one at a time with the other set to 0, but the final model uses α=1 and β=0.6. The table does not show the joint configuration; please clarify how the final values were selected from these one-dimensional sweeps.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; the central claims are empirical improvements on external benchmarks and do not reduce by construction to fitted inputs or self-citations.

full rationale

The paper's central claim is that applying MGS3 to pre-trained code representation models improves retrieval on multiple granularity benchmarks. This claim is evaluated on external benchmarks (Adv, CoSQA, XLCoST-FL, SO-DS, StaQC, XLCoST-BL, CoNaLa) that are not constructed from the paper's own fitted values. The training objective in Eq. 8 is a weighted sum of contrastive losses with hyperparameters alpha=1 and beta=0.6 selected by standard sensitivity analysis, not fitted to the evaluation targets. The MaxSim positive-sample selection is explicitly inspired by ColBERT [22], an external method, and the negative-sample construction is a stated design choice rather than a renamed output. The paper's self-citations [27, 28] appear only as related-work context and are not load-bearing for the claimed contribution. The only admitted weakness, the heuristic comment-code alignment flaw in Section 3.1, concerns data quality and potential label noise; it does not make any prediction equivalent to an input by definition. The paper even acknowledges a distribution overlap for XLCoST-BL, which is an evaluation caveat rather than a circular derivation. Overall, the derivation chain is self-contained and the empirical results are not forced by construction.

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

The central empirical claim depends on the quality of the heuristic comment-code alignment and on the loss weights; no theoretical derivation is provided, so these are the main external inputs.

free parameters (3)
  • alpha (block-level loss weight) = 1.0
    Chosen from {0.2, 0.4, 0.6, 0.8, 1.0} via sensitivity experiments on Adv, StaQC, CoNaLa (Table 8); affects the balance of the training objective in Eq. 8.
  • beta (statement-level loss weight) = 0.6
    Chosen from the same sensitivity sweep; affects the balance of the training objective in Eq. 8.
  • temperature tau = not reported (selected from 0.05, 0.1, 0.2)
    InfoNCE temperature in Eq. 2; the final value is not stated in the paper.
assumptions (3)
  • domain assumption Inline comments describe the code snippet that follows them, and trailing comments describe the statement on the current line.
    Used to construct the MGCodeSearchNet training pairs (Section 3.1); if this heuristic is frequently wrong, the learned alignments are noisy.
  • domain assumption An AST subtree provides the correct hierarchy for aggregating fine-grained code representations.
    HMGR in Section 5.2 aggregates child node representations according to the AST; this assumes syntax structure matches semantic composition.
  • domain assumption Non-nested same-granularity snippets in one function serve as hard negatives for contrastive learning.
    Section 5.3.2 and Appendix C; assumes snippets that share function context are semantically distinct enough to be negatives.

how reviews work

0 comments
Cite this review

Pith. "Pith review of MGS3: A Multi-Granularity Self-Supervised Code Search Framework." pith.science (2026). https://pith.science/paper/6WKQ3XBR

@misc{pith2026250524274,
  author       = {Pith},
  title        = {Pith review of: MGS3: A Multi-Granularity Self-Supervised Code Search Framework},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/6WKQ3XBR}},
  note         = {Machine review of arXiv:2505.24274}
}
abstract

In the pursuit of enhancing software reusability and developer productivity, code search has emerged as a key area, aimed at retrieving code snippets relevant to functionalities based on natural language queries. Despite significant progress in self-supervised code pre-training utilizing the vast amount of code data in repositories, existing methods have primarily focused on leveraging contrastive learning to align natural language with function-level code snippets. These studies have overlooked the abundance of fine-grained (such as block-level and statement-level) code snippets prevalent within the function-level code snippets, which results in suboptimal performance across all levels of granularity. To address this problem, we first construct a multi-granularity code search dataset called MGCodeSearchNet, which contains 536K+ pairs of natural language and code snippets. Subsequently, we introduce a novel Multi-Granularity Self-Supervised contrastive learning code Search framework (MGS$^{3}$}). First, MGS$^{3}$ features a Hierarchical Multi-Granularity Representation module (HMGR), which leverages syntactic structural relationships for hierarchical representation and aggregates fine-grained information into coarser-grained representations. Then, during the contrastive learning phase, we endeavor to construct positive samples of the same granularity for fine-grained code, and introduce in-function negative samples for fine-grained code. Finally, we conduct extensive experiments on code search benchmarks across various granularities, demonstrating that the framework exhibits outstanding performance in code search tasks of multiple granularities. These experiments also showcase its model-agnostic nature and compatibility with existing pre-trained code representation models.

Figures

Figures reproduced from arXiv: 2505.24274 by the authors.

Figure 1
Figure 1. Examples of functions in the repository, which [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 2
Figure 2. The overview of MGS3 . (a) Different granularity code snippets. (b) Depicts the abstract syntax tree (AST) corresponding to the code snippets, retaining only the statement and block nodes. (c) Illustrates the bi-encoder model using MaxSim for contrastive learning among code snippets. (d) The hierarchical aggregation in HMGR guided by AST. 5.2 Hierarchical Multi-Granularity Representation Due to the need for represen… view at source ↗
Figure 3
Figure 3. Results of ablation study on different granularities [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: Visualization of code snippets represented in multiple granularities. Code snippets with the same functionality are [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Visualize the importance of final search scores for [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]
Figure 6
Figure 6. Figure 6: We employed methods for acquiring negative sam [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

56 extracted references · 40 canonical work pages

  1. [1]

    Wasi Ahmad, Saikat Chakraborty, Baishakhi Ray, and Kai-Wei Chang. 2020. A Transformer-based Approach for Source Code Summarization. In Proceedings of KDD ’25, August 3–7, 2025, Toronto, ON, Canada Rui Li et al. the 58th Annual Meeting of the Association for Computational Linguistics . 4998– 5007

    work page 2020

  2. [2]

    Miltiadis Allamanis, Marc Brockschmidt, and Mahmoud Khademi. 2018. Learning to Represent Programs with Graphs. In International Conference on Learning Representations. https://openreview.net/forum?id=BJOFETxR-

    work page 2018

  3. [3]

    Uri Alon, Shaked Brody, Omer Levy, and Eran Yahav. 2018. code2seq: Generating Sequences from Structured Representations of Code. In International Conference on Learning Representations

    work page 2018

  4. [4]

    Nghi DQ Bui, Yijun Yu, and Lingxiao Jiang. 2021. Self-supervised contrastive learning for code retrieval and summarization via semantic-preserving trans- formations. In Proceedings of the 44th International ACM SIGIR Conference on Research and Development in Information Retrieval . 511–521

    work page 2021

  5. [5]

    Lei Chai and Ming Li. 2022. Pyramid Attention For Source Code Summarization. Advances in Neural Information Processing Systems 35 (2022), 20421–20433

    work page 2022

  6. [6]

    Yangruibo Ding, Luca Buratti, Saikat Chakraborty, Saurabh Pujar, Alessandro Morari, and Baishakhi Ray. 2021. Contrastive learning for source code with structural and functional properties. (2021)

    work page 2021

  7. [7]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. 2020. CodeBERT: A Pre-Trained Model for Programming and Natural Languages. In Findings of the Association for Computational Linguistics: EMNLP 2020, Online Event, 16-20 November 2020 (Findings of ACL, Vol. EMNLP 2020) . 153...

    doi:10.18653/v1/ 2020

  8. [8]

    Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. 2022. UniXcoder: Unified Cross-Modal Pre-training for Code Representation. In Pro- ceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), ACL 2022, Dublin, Ireland, May 22-27, 2022 . 7212–7225. doi:10.18653/v1/2022.acl-long.499

    doi:10.18653/v1/2022.acl-long.499 2022

Show all 56 references
  1. [9]

    Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou

    Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, Shujie Liu, Long Zhou, Nan Duan, Alexey Svyatkovskiy, Shengyu Fu, Michele Tufano, Shao Kun Deng, Colin B. Clement, Dawn Drain, Neel Sundaresan, Jian Yin, Daxin Jiang, and Ming Zhou. 2021. GraphCodeBERT: Pre-training Code ...

    2021

  2. [10]

    Kaiming He, Haoqi Fan, Yuxin Wu, Saining Xie, and Ross Girshick. 2020. Mo- mentum contrast for unsupervised visual representation learning. In Proceedings of the IEEE/CVF conference on computer vision and pattern recognition . 9729–9738

    2020

  3. [11]

    Liyang He, Zhenya Huang, Enhong Chen, Qi Liu, Shiwei Tong, Hao Wang, Defu Lian, and Shijin Wang. 2023. An efficient and robust semantic hashing framework for similar text search. ACM Transactions on Information Systems 41, 4 (2023), 1–31

    2023

  4. [12]

    Liyang He, Zhenya Huang, Chenglong Liu, Rui Li, Runze Wu, Qi Liu, and Enhong Chen. 2024. One-bit deep hashing: Towards resource-efficient hashing model with binary neural network. In Proceedings of the 32nd ACM International Conference on Multimedia. 7162–7171

    2024

  5. [13]

    Geert Heyman and Tom Van Cutsem. 2020. Neural code search revisited: En- hancing code snippet retrieval through natural language intent. arXiv preprint arXiv:2008.12193 (2020)

    2020 arXiv

  6. [14]

    Xing Hu, Ge Li, Xin Xia, David Lo, and Zhi Jin. 2018. Deep code comment generation. In Proceedings of the 26th conference on program comprehension . 200– 210

    2018

  7. [15]

    Xing Hu, Ge Li, Xin Xia, David Lo, and Zhi Jin. 2020. Deep code comment generation with hybrid lexical and syntactical information. Empirical Software Engineering 25 (2020), 2179–2217

    2020

  8. [16]

    Junjie Huang, Duyu Tang, Linjun Shou, Ming Gong, Ke Xu, Daxin Jiang, Ming Zhou, and Nan Duan. 2021. CoSQA: 20,000+ Web Queries for Code Search and Question Answering. In Proceedings of the 59th Annual Meeting of the Associa- tion for Computational Linguistics and the 11th Inte...

    2021

  9. [17]

    David A Hull. 1999. Xerox TREC-8 Question Answering Track Report.. In TREC

    1999

  10. [18]

    Hamel Husain, Ho-Hsiang Wu, Tiferet Gazit, Miltiadis Allamanis, and Marc Brockschmidt. 2019. Codesearchnet challenge: Evaluating the state of semantic code search. arXiv preprint arXiv:1909.09436 (2019)

    2019 arXiv

  11. [19]

    Srinivasan Iyer, Ioannis Konstas, Alvin Cheung, and Luke Zettlemoyer. 2016. Sum- marizing source code using a neural attention model. In 54th Annual Meeting of the Association for Computational Linguistics 2016. Association for Computational Linguistics, 2073–2083

    2016

  12. [20]

    Paras Jain, Ajay Jain, Tianjun Zhang, Pieter Abbeel, Joseph Gonzalez, and Ion Stoica. 2021. Contrastive Code Representation Learning. In Proceedings of the 2021 Conference on Empirical Methods in Natural Language Processing. 5954–5971

    2021

  13. [21]

    Aditya Kanade, Petros Maniatis, Gogul Balakrishnan, and Kensen Shi. 2020. Learning and Evaluating Contextual Embedding of Source Code. In International Conference on Machine Learning . 5110–5121

    2020

  14. [22]

    Omar Khattab and Matei Zaharia. 2020. Colbert: Efficient and effective passage search via contextualized late interaction over bert. In Proceedings of the 43rd International ACM SIGIR conference on research and development in Information Retrieval. 39–48

    2020

  15. [23]

    Alexander LeClair, Sakib Haque, Lingfei Wu, and Collin McMillan. 2020. Im- proved code summarization via a graph neural network. In Proceedings of the 28th international conference on program comprehension . 184–195

    2020

  16. [24]

    Haochen Li, Chunyan Miao, Cyril Leung, Yanxian Huang, Yuan Huang, Hongyu Zhang, and Yanlin Wang. 2022. Exploring Representation-level Augmentation for Code Search. In Proceedings of the 2022 Conference on Empirical Methods in Natural Language Processing. 4924–4936

    2022

  17. [25]

    Haochen Li, Xin Zhou, Anh Luu, and Chunyan Miao. 2023. Rethinking Negative Pairs in Code Search. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing . 12760–12774

    2023

  18. [26]

    Mingjia Li, Hong Qian, Jinglan Lv, Mengliang He, Wei Zhang, and Aimin Zhou

  19. [27]

    Rui Li, Liyang He, Qi Liu, Yuze Zhao, Zheng Zhang, Zhenya Huang, Yu Su, and Shijin Wang. 2024. CONSIDER: Commonalities and Specialties Driven Multilingual Code Retrieval Framework. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 38. 8679–8687

    2024

  20. [28]

    Rui Li, Qi Liu, Liyang He, Zheng Zhang, Hao Zhang, Shengyu Ye, Junyu Lu, and Zhenya Huang. 2024. Optimizing Code Retrieval: High-Quality and Scalable Dataset Annotation through Large Language Models. In Proceedings of the 2024 Conference on Empirical Methods in Natural Languag...

    2024

  21. [29]

    Xiaonan Li, Yeyun Gong, Yelong Shen, Xipeng Qiu, Hang Zhang, Bolun Yao, Weizhen Qi, Daxin Jiang, Weizhu Chen, and Nan Duan. 2022. CodeRetriever: A Large Scale Contrastive Pre-Training Method for Code Search. In Proceedings of the 2022 Conference on Empirical Methods in Natural...

    2022

  22. [30]

    Qi Liu, Zhenya Huang, Yu Yin, Enhong Chen, Hui Xiong, Yu Su, and Guoping Hu

  23. [31]

    Ilya Loshchilov and Frank Hutter. 2017. Fixing Weight Decay Regularization in Adam. CoRR abs/1711.05101 (2017). arXiv:1711.05101 http://arxiv.org/abs/1711. 05101

    2017 arXiv

  24. [32]

    Shuai Lu, Daya Guo, Shuo Ren, Junjie Huang, Alexey Svyatkovskiy, Ambrosio Blanco, Colin B. Clement, Dawn Drain, Daxin Jiang, Duyu Tang, Ge Li, Lidong Zhou, Linjun Shou, Long Zhou, Michele Tufano, Ming Gong, Ming Zhou, Nan Duan, Neel Sundaresan, Shao Kun Deng, Shengyu Fu, and S...

    2021

  25. [33]

    Aaron van den Oord, Yazhe Li, and Oriol Vinyals. 2018. Representation learning with contrastive predictive coding. arXiv preprint arXiv:1807.03748 (2018)

    2018 arXiv

  26. [34]

    Yingqi Qu, Yuchen Ding, Jing Liu, Kai Liu, Ruiyang Ren, Wayne Xin Zhao, Daxi- ang Dong, Hua Wu, and Haifeng Wang. 2021. RocketQA: An Optimized Training Approach to Dense Passage Retrieval for Open-Domain Question Answering. In Proceedings of the 2021 Conference of the North Am...

    2021

  27. [35]

    Juan Ramos et al. 2003. Using tf-idf to determine word relevance in document queries. In Proceedings of the first instructional conference on machine learning , Vol. 242. Citeseer, 29–48

    2003

  28. [36]

    Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedan- tam, Devi Parikh, and Dhruv Batra. 2017. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE interna- tional conference on computer vision . 618–626

    2017

  29. [37]

    Ensheng Shi, Yanlin Wang, Lun Du, Hongyu Zhang, Shi Han, Dongmei Zhang, and Hongbin Sun. 2021. CAST: Enhancing Code Summarization with Hierarchical Splitting and Reconstruction of Abstract Syntax Trees. In Proceedings of the 2021 Conference on Empirical Methods in Natural Lang...

    2021

  30. [38]

    Laurens van der Maaten and Geoffrey E. Hinton. 2008. Visualizing Data using t-SNE. Journal of Machine Learning Research 9 (2008), 2579–2605. https://api. semanticscholar.org/CorpusID:5855042

    2008

  31. [39]

    Fei Wang, Qi Liu, Enhong Chen, Zhenya Huang, Yu Yin, Shijin Wang, and Yu Su

  32. [40]

    Xin Wang, Yasheng Wang, Fei Mi, Pingyi Zhou, Yao Wan, Xiao Liu, Li Li, Hao Wu, Jin Liu, and Xin Jiang. 2021. Syncobert: Syntax-guided multi-modal contrastive pre-training for code representation. arXiv preprint arXiv:2108.04556 (2021)

    2021 arXiv

  33. [41]

    Yue Wang, Hung Le, Akhilesh Deepak Gotmare, Nghi DQ Bui, Junnan Li, and Steven CH Hoi. 2023. Codet5+: Open code large language models for code understanding and generation. arXiv preprint arXiv:2305.07922 (2023)

    2023 arXiv

  34. [42]

    Bolin Wei, Ge Li, Xin Xia, Zhiyi Fu, and Zhi Jin. 2019. Code generation as a dual task of code summarization. Advances in neural information processing systems 32 (2019)

    2019

  35. [43]

    Lee Xiong, Chenyan Xiong, Ye Li, Kwok-Fung Tang, Jialin Liu, Paul N Bennett, Junaid Ahmed, and Arnold Overwijk. 2020. Approximate Nearest Neighbor Neg- ative Contrastive Learning for Dense Text Retrieval. In International Conference on Learning Representations

    2020

  36. [44]

    Ziyu Yao, Daniel S Weld, Wei-Peng Chen, and Huan Sun. 2018. Staqc: A system- atically mined question-code dataset from stack overflow. In Proceedings of the 2018 World Wide Web Conference. 1693–1703. MGS3: A Multi-Granularity Self-Supervised Code Search Framework KDD ’25, Augu...

    2018

  37. [45]

    Pengcheng Yin, Bowen Deng, Edgar Chen, Bogdan Vasilescu, and Graham Neubig

  38. [46]

    Hang Zhang, Yeyun Gong, Yelong Shen, Jiancheng Lv, Nan Duan, and Weizhu Chen. 2021. Adversarial Retriever-Ranker for Dense Text Retrieval. In Interna- tional Conference on Learning Representations

    2021

  39. [47]

    Kechi Zhang, Zhuo Li, Zhi Jin, and Ge Li. 2023. Implant Global and Local Hierarchy Information to Sequence based Code Representation Models. arXiv preprint arXiv:2303.07826 (2023)

    2023 arXiv

  40. [48]

    Zheng Zhang, Qi Liu, Zirui Hu, Yi Zhan, Zhenya Huang, Weibo Gao, and Qingyang Mao. 2024. Enhancing Fairness in Meta-learned User Modeling via Adaptive Sampling. InProceedings of the ACM on Web Conference 2024. 3241–3252

    2024

  41. [49]

    Zheng Zhang, Qi Liu, Hao Jiang, Fei Wang, Yan Zhuang, Le Wu, Weibo Gao, and Enhong Chen. [n. d.]. Fairlisa: Fair user modeling with limited sensitive attributes information. In Thirty-seventh Conference on Neural Information Pro- cessing Systems

  42. [50]

    Hongke Zhao, Chuang Zhao, Xi Zhang, Nanlin Liu, Hengshu Zhu, Qi Liu, and Hui Xiong. 2023. An ensemble learning approach with gradient resampling for class-imbalance problems. INFORMS Journal on Computing 35, 4 (2023), 747–763

    2023

  43. [51]

    Ming Zhu, Aneesh Jain, Karthik Suresh, Roshan Ravindran, Sindhu Tipirneni, and Chandan K Reddy. 2022. Xlcost: A benchmark dataset for cross-lingual code intelligence. arXiv preprint arXiv:2206.08474 (2022). A MGCodeSearchNet details We have compiled the statistics of the curre...

    2022 arXiv

  44. [56]

    XLCoST-FL [51] has gathered programming questions along with corresponding programs in seven different programming languages from the GeeksForGeeks6

    queries are collected from web search engines, thus better verifying the model’s performance in real code search scenar- ios. XLCoST-FL [51] has gathered programming questions along with corresponding programs in seven different programming languages from the GeeksForGeeks6. •...

  45. [2018]

    In Proceedings of the 15th international conference on mining software repositories

    Learning to mine aligned code and natural language pairs from stack overflow. In Proceedings of the 15th international conference on mining software repositories. 476–486

  46. [2019]

    IEEE Transactions on Knowledge and Data Engineering 33, 1 (2019), 100–115

    Ekt: Exercise-aware knowledge tracing for student performance prediction. IEEE Transactions on Knowledge and Data Engineering 33, 1 (2019), 100–115

    2019

  47. [2022]

    IEEE Transactions on Knowledge and Data Engineering 35, 8 (2022), 8312–8327

    NeuralCD: a general framework for cognitive diagnosis. IEEE Transactions on Knowledge and Data Engineering 35, 8 (2022), 8312–8327

    2022

  48. [2025]

    Frontiers of Computer Science 19, 1 (2025), 191318

    Foundation model enhanced derivative-free cognitive diagnosis. Frontiers of Computer Science 19, 1 (2025), 191318

    2025

Pith tools

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