Pith. sign in

REVIEW 4 major objections 5 minor 50 references

Identifying Root Cause of bugs by Capturing Changed Code Lines with Relational Graph Neural Networks

T0 review · 4 major / 5 minor · reviewed 2026-08-16 · deepseek-v4-flash

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

Pith's one-line read RC-Detection claims that ranking deleted lines in a bug-fixing commit with a relational graph convolutional network identifies the true root-cause line better than prior SZZ-based methods.

desk verdict A coherent incremental GNN method for root-cause line ranking, but the evaluation rests on the same label oracle as its main baseline and the dataset count does not add up. read the letter →

arxiv 2505.00990 v1 pith:VPOMEJIE submitted 2025-05-02 cs.SE

Jiaqi Zhang , Shikai Guo , Hui Li , Chenchen Li , Yu Chai , Rong Chen This is my paper · ORCID
classification cs.SE
keywords rootcausedetectionSZZalgorithmrelationalgraphconvolutionalnetworkchangedcodelinesJust-In-Timedefectpredictionheterogeneousranking
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 tries to show that the deleted lines truly responsible for a bug can be ranked above the noise of a bug-fixing commit by modeling the changed code as a graph. Its method, RC-Detection, builds a heterogeneous graph whose nodes are added and deleted lines and whose edges are control-flow, data-dependency, call, and line-mapping relations, then converts it to a homogeneous graph whose type information is preserved as extra vectors. A relational graph convolutional network propagates semantic information through this graph, and a pairwise ranker orders deleted lines by root-cause probability. On three Java datasets totaling 87 projects and 675 bug-fix commits, the paper reports Recall@1, Recall@2, and Recall@3 of 0.811, 0.884, and 0.924, and a mean first rank of 1.830, all better than the prior state of the art. If this holds, Just-In-Time defect prediction gets a sharper, line-level signal about which deletion actually caused the bug.

What carries the argument

The mechanism is the relational graph convolutional network (RGCN), defined as a message-passing layer that updates each node's hidden state by summing, for every edge relation, a relation-specific weight matrix applied to neighboring node states plus a self-connection. Basis decomposition keeps the parameter count manageable by expressing each relation weight matrix as a linear combination of shared basis matrices. Before the RGCN layer, the graph type conversion component merges node and edge feature matrices into one homogeneous graph while appending type vectors, which preserves the identity of different node and edge kinds even after unification. This combination is what carries the argument: without per-relation aggregation the semantic relationships among changed lines are not exploited, and without the type-preserving conversion the heterogeneous feature dimensions cannot be integrated without over-parameterization.

What would settle it

Take a random sample of the 675 bug-fixing commits, have developers or independent annotators mark the true root-cause deleted line from the bug report, and recompute Recall@1, Recall@2, Recall@3, and MFR on that manually labeled subset. If RC-Detection's Recall@1 does not remain above the NEURAL-SZZ baseline on that subset, the central claim of improved root-cause identification fails.

Watch

Extended reading notes

Core claim

The paper's central claim is that root-cause identification in bug-fixing commits reduces to ranking deleted code lines by semantic relatedness to the other changed lines, and that relational graph convolutional networks are the right machinery for that ranking. Given a bug-fixing commit, RC-Detection extracts deleted and added lines as nodes, connects them with edges drawn from control-flow graphs, data-dependency graphs, call graphs, and class-member reference graphs, and adds line-mapping edges between corresponding old and new lines. It then merges the heterogeneous node and edge features into one homogeneous graph while encoding node and edge type as additional vectors, embeds each code statement with CodeBERT, and applies an RGCN whose relation-specific weights are regularized by basis decomposition. Deleted lines are assigned probabilities and ranked with RankNet. The paper reports Recall@1 of 0.811, Recall@2 of 0.884, Recall@3 of 0.924, and MFR of 1.830, which it states are improvements of 4.107%, 5.113%, 4.289%, and 24.536% over the strongest baseline, and concludes that the type-conversion plus relation-aware aggregation is what earns the gain.

Load-bearing premise

The evaluation assumes that the root-cause labels produced by the adopted SZZ-style tracing pipeline are accurate; if those labels are noisy or carry the same biases as the main baseline, the reported improvements are relative to that pipeline rather than to the true root cause of each bug.

Editorial extensions

If this is right

  • Root-cause identification can be treated as a learned ranking problem on code graphs rather than a filtering problem, so the top-ranked deleted line can directly steer SZZ-style labeling of bug-inducing changes.
  • JIT defect prediction can consume line-level root-cause signals instead of whole-commit labels, which should reduce the false positives and false negatives caused by noisy bug-inducing change labels.
  • The reported MFR of 1.830 means the true root-cause deleted line appears, on average, within the first two ranked positions, which is within reach of a developer's manual review.
  • The ablation results imply that relation-type awareness is the active ingredient: replacing RGCN with non-relational graph convolutions consistently lowers Recall@1, so keeping distinct relation types matters.
  • Retaining both added and deleted lines as graph nodes is necessary, because lines of both kinds carry semantic evidence about which deletion caused the bug.

Reading between the lines

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

  • Because the metrics are computed against labels produced by the same SZZ-style pipeline that the main baseline uses, part of the reported edge may reflect agreement with that pipeline's inductive biases rather than with independently verified root causes; a manual-oracle study would settle this.
  • The graph type conversion step is generic enough to apply to other heterogeneous program graphs, such as combining abstract syntax trees, dataflow, and call graphs at method level, so it could be tested for fault localization or vulnerability patch discovery.
  • If the ranking signal is genuinely semantic, RC-Detection should transfer to non-Java languages with the same graph construction, so the absence of such data is a concrete testable next step.
  • Embedding the ranker into a commit-time review tool that highlights the top-ranked deleted line as a suspected root cause is a plausible productization, given the reported mean first rank below two.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes RC-Detection, a relational graph convolutional network (RGCN) approach that ranks deleted code lines in bug-fixing commits as candidate root causes of the introduced bug. The pipeline constructs a heterogeneous graph from AST, CFG, DDG, call graph, and class-member-reference relationships between added and deleted lines, converts it into a homogeneous graph with type vectors, embeds code statements with CodeBERT, applies a two-layer RGCN, and ranks deletion nodes with RankNet trained by focal loss. The evaluation compares RC-Detection with NEURAL-SZZ and several machine-learning and deep-learning baselines on three Java datasets, reporting improvements in Recall@1, Recall@2, Recall@3, and MFR, with the headline numbers being 0.811, 0.884, 0.924, and 1.830 and relative gains of 4.107%, 5.113%, 4.289%, and 24.536% over the state of the art.

Significance. If the reported results are trustworthy, RC-Detection would be a useful contribution to SZZ noise reduction and just-in-time defect prediction: the model is clearly described, the graph type conversion is a sensible response to feature-dimension mismatch in heterogeneous code graphs, and the ablations over embedding models, GNN variants, layer counts, regularization, and loss functions are extensive. The paper also specifies its cross-validation strategy and states an intention to release code. However, the evaluation is not currently convincing: the dataset arithmetic is internally inconsistent, the ground-truth labels are inherited from the same pipeline family as the main baseline without independent validation, the headline numbers are point estimates without significance tests, and hyperparameters are selected on the same cross-validation folds used for reporting. Because these issues affect every reported table, the claimed improvements are not yet established.

major comments (4)
  1. [Abstract / Section 6.2 / Table 1] The dataset description is internally inconsistent. The abstract and Section 6.2 state that the study uses 675 bug-fixing commits and 87 projects, but Table 1 lists 241 + 957 + 291 = 1,489 bug-fixing commits and 351 + 957 + 378 = 1,686 bug-inducing commits, and the project counts in the three blocks do not obviously sum to 87. If the evaluation used the full Table 1 union, the '675 commits' claim is wrong; if it used a 675-commit subset, the selection procedure is never specified. Tables 2 through 7 are aggregate rankings, so this discrepancy is load-bearing for every reported result. Please reconcile these counts and precisely describe the evaluation corpus.
  2. [Section 4.2 / Section 4.4 / Section 6.1] The ground-truth labels are obtained by 'adopting the processing methods used by Tang et al.' (Section 4.2), and the strongest baseline, NEURAL-SZZ, is exactly Tang et al.'s method (Section 4.4). There is no independent oracle, no manual validation sample, and no label-error analysis in the manuscript, and Section 6.1 discusses only the accuracy of reproducing the compared methods, not the quality or bias of the adopted labels. If the Tang et al. labeling pipeline encodes particular heuristics about which deleted lines are root causes, models adapted to that same pipeline have a built-in advantage, and the measured gains may not transfer to independently labeled data. Please add an external validation of a sample of labels and report agreement against an independent oracle.
  3. [Section 5.1 / Table 2 / Section 5.4] The headline comparison in Table 2 consists of single point estimates with no confidence intervals or significance tests, so the 0.032 gap in Recall@1 between RC-Detection and NEURAL-SZZ is not shown to be outside cross-validation noise. Moreover, Section 5.4 selects the number of RGCN layers and the regularization setting by comparing Recall@1 on the same ten-fold cross-validation folds that are later used to report final performance; this is a tuning-on-test procedure that biases the reported numbers. Please report per-fold distributions with significance tests and perform hyperparameter selection on a separate validation split.
  4. [Section 5.1 Results / Section 5.4 Results] The relative-improvement claims contain internal inconsistencies. Section 5.1 states that RC-Detection 'outperforms Neural SZZ by 69.8%, 52.1%, in MFR,' which contradicts the abstract and Section 5.1 Conclusion, both of which report a 24.536% MFR improvement. In Section 5.4, the model with two layers is described as best on 'Recall@1 and Recall@2' with scores 0.811 and 0.924, but 0.924 is the Recall@3 column in Table 5. Please correct these numbers so that the reported gains are auditable.
minor comments (5)
  1. [Section 6.2 / Table 1] The project count should be made consistent with Table 1: if '120 more projects' is additional to the five named entries in the second block, the table implies 135 projects, not 87 as stated in the abstract and Section 6.2.
  2. [Section 3.4.3] The heading 'Deletion Nodes Rankling Layer' should read 'Ranking Layer,' and the document should be checked for similar typos, including 'DTection' in Section 4.1 and 'bus' in Section 3.4.
  3. [Introduction / Section 8] The promise to release code and datasets is not yet fulfilled; please provide a working artifact link or clearly state the planned availability so that the experiments can be reproduced.
  4. [Section 5.1] The sentence 'Considering Neural SZZ using heterogeneous graph neural network, the substantial improvement...' is grammatically incomplete and should be rephrased.
  5. [Section 5.2] The sentence beginning 'Compared to the SOTA methods reported in Section 5.1, RC-Detection with BERT model outperforms them...' is confusing because the proposed method already includes CodeBERT; please clarify which configuration is being compared with which baseline.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: RC-Detection is a standard supervised graph-learning pipeline evaluated on externally sourced SZZ-based labels, and no reported result reduces to its inputs by construction.

full rationale

The paper's central claim is empirical: RC-Detection ranks deleted code lines using a relational graph convolutional network and is evaluated with Recall@N and MFR. The derivation chain is a conventional supervised learning setup: code lines and their relations are converted into a homogeneous graph, node embeddings are obtained from CodeBERT, an RGCN produces per-deleted-line probabilities, and RankNet orders the deleted lines. No equation in the paper makes the predicted ranking equal to the training labels by construction; the model parameters are learned from the data and the evaluation is performed under ten-fold cross-validation. The closest potential concern is that Section 4.2 states that true labels were obtained by 'adopting the processing methods used by Tang et al.,' and the strongest baseline is Tang et al.'s NEURAL-SZZ, which is trained on the same labeling pipeline. This is a real shared-oracle limitation and a threat to external validity, but it is not circularity under the stated criteria: the labels are an externally constructed target, not an output of RC-Detection, and the paper does not fit a parameter and then rename that fit as a prediction. The dataset-count inconsistency in Table 1 and Section 6.2 (675 commits versus 241+957+291=1,489 bug-fixing commits) is a serious auditability and correctness concern, but it is not a circular derivation. There is no load-bearing self-citation chain, no uniqueness theorem imported from the authors, and no ansatz smuggled in via citation. Accordingly, the honest finding is no significant circularity, with a score of 0.

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

No new physical or conceptual entities are introduced; the method combines existing components. The central claim rests on task-level assumptions about root cause granularity, label quality, graph construction, and dataset representativeness, plus hand-chosen hyperparameters.

free parameters (7)
  • num_bases in RGCN = 30
    Set by hand in Section 4.5; controls the number of basis functions in basis decomposition and can affect ranking quality.
  • number of RGCN layers = 2
    Selected in Section 5.4 because this configuration gave the best Recall@1 on the evaluated folds; the layer count directly changes the model.
  • learning_rate = 5e-6
    Set in Section 4.5 with no reported validation sweep.
  • batch_size = 128
    Set in Section 4.5 with no reported validation sweep.
  • training_epochs = 20
    Set in Section 4.5; no early stopping or epoch sensitivity analysis is reported.
  • focal_loss_alpha = not reported
    Focal loss (Equation 16) includes alpha_t, but the concrete value used in experiments is not given.
  • focal_loss_gamma = not reported
    Focal loss (Equation 16) includes gamma, but the concrete value used in experiments is not given.
assumptions (5)
  • domain assumption A deleted line in a bug-fixing commit is the correct unit at which a root cause can be identified.
    The entire method ranks deletion nodes; added lines are only context. The paper does not justify this unit choice against alternative granularities such as statements, expressions, or commit-level causes.
  • domain assumption The true labels produced by adopting Tang et al.'s processing pipeline are accurate enough for training and evaluation.
    Section 4.2 explicitly adopts those labels as ground truth and uses them to evaluate against Tang et al.'s method. If these labels are noisy, all reported metrics are affected.
  • domain assumption The Mapping(Dnode, Anode) function in Algorithm 1 reliably maps deleted lines to corresponding added lines.
    Line-mapping edges connect the deletion graph to the addition graph; an incorrect mapping would introduce false relationships between changed code lines.
  • domain assumption DFS reachability paths in CFG, DDG, CG, and CMFG capture the semantic relationships relevant to root cause detection.
    Section 3.2 adds an edge whenever a path exists between two nodes in these graphs; this can create arbitrary connections and depends on the quality of the constructed program graphs.
  • domain assumption The three Java datasets are representative enough to support the claimed generalization of the method.
    Section 6.2 concedes that only Java projects are included and that the total number of commits is limited. The paper still presents the method as generally effective.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Identifying Root Cause of bugs by Capturing Changed Code Lines with Relational Graph Neural Networks." pith.science (2026). https://pith.science/paper/VPOMEJIE

@misc{pith2026250500990,
  author       = {Pith},
  title        = {Pith review of: Identifying Root Cause of bugs by Capturing Changed Code Lines with Relational Graph Neural Networks},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VPOMEJIE}},
  note         = {Machine review of arXiv:2505.00990}
}
read the original abstract

The Just-In-Time defect prediction model helps development teams improve software quality and efficiency by assessing whether code changes submitted by developers are likely to introduce defects in real-time, allowing timely identification of potential issues during the commit stage. However, two main challenges exist in current work due to the reality that all deleted and added lines in bug-fixing commits may be related to the root cause of the introduced bug: 1) lack of effective integration of heterogeneous graph information, and 2) lack of semantic relationships between changed code lines. To address these challenges, we propose a method called RC-Detection, which utilizes relational graph convolutional network to capture the semantic relationships between changed code lines. RC-Detection is used to detect root-cause deletion lines in changed code lines, thereby identifying the root cause of introduced bugs in bug-fixing commits. To evaluate the effectiveness of RC-Detection, we used three datasets that contain high-quality bug-fixing and bug-introducing commits. Extensive experiments were conducted to evaluate the performance of our model by collecting data from 87 open-source projects, including 675 bug-fix commits. The experimental results show that, compared to the most advanced root cause detection methods, RC-Detection improved Recall@1, Recall@2, Recall@3, and MFR by at 4.107%, 5.113%, 4.289%, and 24.536%, respectively.

Figures

Figures reproduced from arXiv: 2505.00990 by the authors.

Figure 1
Figure 1. A motivation example of changed code lines [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. The overall framework of RC-Detection extracting the graph structure of the changed code lines [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗
Figure 3
Figure 3. A practical example of graph construction [PITH_FULL_IMAGE:figures/full_fig_p005_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: A practical example of graph type conversion [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]
Figure 5
Figure 5. Figure 5: Diagram for computing the update of a single graph [PITH_FULL_IMAGE:figures/full_fig_p007_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

50 extracted references · 41 canonical work pages

  1. [1]

    I know what you did last summer: an investigation of how developers spend their time

    Roberto Minelli, Andrea Mocci, and Michele Lanza. I know what you did last summer: an investigation of how developers spend their time. International Conference on Program Comprehen- sion,International Conference on Program Comprehension, May 2015

    work page 2015

  2. [2]

    MA Branch, Michael Jackson, MC Laviolette, and EricC. Frankel. Software maintenance management. International Conference on Software Maintenance,International Conference on Software Mainte- nance, Jan 1986

    work page 1986

  3. [3]

    Hassan, Audris Mockus, Anand Sinha, and Naoyasu Ubayashi

    Yasutaka Kamei, Emad Shihab, Bram Adams, Ahmed E. Hassan, Audris Mockus, Anand Sinha, and Naoyasu Ubayashi. A large- scale empirical study of just-in-time quality assurance. IEEE Transactions on Software Engineering, page 757–773, Jun 2013

    work page 2013

  4. [4]

    Graph autoencoder anomaly detection for e- commerce application by contextual integrating contrast with re- construction and complementarity

    Jinjie Wu, Zhipeng Qiu, Zhixia Zeng, Ruliang Xiao, Imad Rida, and Shi Zhang. Graph autoencoder anomaly detection for e- commerce application by contextual integrating contrast with re- construction and complementarity. IEEE Transactions on Consumer Electronics, 70(1):1623–1630, 2024

    work page 2024

  5. [5]

    Knowledge graph enhanced heterogeneous graph neural network for fake news detection

    Bingbing Xie, Xiaoxiao Ma, Jia Wu, Jian Yang, and Hao Fan. Knowledge graph enhanced heterogeneous graph neural network for fake news detection. IEEE Transactions on Consumer Electronics, 70(1):2826–2837, 2024

    work page 2024

  6. [6]

    Anomaly detection with memory-augmented adversarial autoencoder networks for industry 5.0

    Huan Zhang, Neeraj Kumar, Sheng Wu, Chunlei Wu, Jian Wang, and Peiying Zhang. Anomaly detection with memory-augmented adversarial autoencoder networks for industry 5.0. IEEE Transac- tions on Consumer Electronics, 2023

    work page 2023

  7. [7]

    Audris Mockus and David M. Weiss. Predicting risk of software changes. Bell Labs Technical Journal, page 169–180, Oct 2002

    work page 2002

  8. [8]

    James Whitehead, and Yi Zhang

    Sunghun Kim, E. James Whitehead, and Yi Zhang. Classifying software changes: Clean or buggy? IEEE Transactions on Software Engineering, page 181–196, Mar 2008

    work page 2008

Show all 50 references
  1. [9]

    Hassan, and Shanping Li

    Yuanrui Fan, Xin Xia, Daniel Alencar da Costa, David Lo, Ahmed E. Hassan, and Shanping Li. The impact of mislabeled changes by szz on just-in-time defect prediction. IEEE Transactions on Software Engineering, page 1559–1586, Aug 2021

    2021

  2. [10]

    Daniel Alencar da Costa, Shane McIntosh, Weiyi Shang, Uira Kulesza, Roberta Coelho, and Ahmed E. Hassan. A framework for evaluating the results of the szz approach for identifying bug- introducing changes. IEEE Transactions on Software Engineering , page 641–657, Jul 2017

    2017

  3. [11]

    James Jr

    Sunghun Kim, Thomas Zimmermann, Kai Pan, and E. James Jr. Whitehead. Automatic identification of bug-introducing changes. In 21st IEEE/ACM International Conference on Automated Software Engineering (ASE’06), Sep 2006

    2006

  4. [12]

    Yasutaka Kamei, Shinsuke Matsumoto, Akito Monden, Ken-ichi Matsumoto, Bram Adams, and Ahmed E. Hassan. Revisiting common bug prediction findings using effort-aware models. In 2010 IEEE International Conference on Software Maintenance , Sep 2010

    2010

  5. [13]

    When do changes induce fixes? ACM sigsoft software engineering notes , 30(4):1–5, 2005

    Jacek ´Sliwerski, Thomas Zimmermann, and Andreas Zeller. When do changes induce fixes? ACM sigsoft software engineering notes , 30(4):1–5, 2005

    2005

  6. [14]

    The impact of refactoring changes on the szz algorithm: An empirical study

    Edmilson Campos Neto, Daniel Alencar da Costa, and Uira Kulesza. The impact of refactoring changes on the szz algorithm: An empirical study. In 2018 IEEE 25th International Conference on Software Analysis, Evolution and Reengineering (SANER) , Mar 2018

    2018

  7. [15]

    Neural szz algorithm

    Lingxiao Tang, Lingfeng Bao, Xin Xia, and Zhongdong Huang. Neural szz algorithm. In 2023 38th IEEE/ACM International Con- ference on Automated Software Engineering (ASE) , pages 1024–1035. IEEE, 2023

    2023

  8. [16]

    Mining heterogeneous information networks

    Yizhou Sun and Jiawei Han. Mining heterogeneous information networks. ACM SIGKDD Explorations Newsletter , page 20–28, Apr 2013

    2013

  9. [17]

    Kipf, Peter Bloem, Rianne van·den Berg, Ivan Titov, and Max Welling

    Michael Schlichtkrull, Thomas N. Kipf, Peter Bloem, Rianne van·den Berg, Ivan Titov, and Max Welling. Modeling Relational Data with Graph Convolutional Networks, page 593–607. Jan 2018

    2018

  10. [18]

    Exploring and exploiting the correlations between bug-inducing and bug-fixing commits

    Ming Wen, Rongxin Wu, Yepang Liu, Yongqiang Tian, Xuan Xie, Shing-Chi Cheung, and Zhendong Su. Exploring and exploiting the correlations between bug-inducing and bug-fixing commits. In Proceedings of the 2019 27th ACM Joint Meeting on European Software Engineering Conference a...

    2019

  11. [19]

    Regminer: Towards constructing a large regression dataset from code evolution history

    Xuezhi Song, Yun Lin, SiangHwee Ng, Yijian Wu, Xin Peng, JinSong Dong, and Hong Mei. Regminer: Towards constructing a large regression dataset from code evolution history. Sep 2021

    2021

  12. [20]

    Revisiting and improving szz implementations

    Edmilson Campos Neto, Daniel Alencar da Costa, and Uira Kulesza. Revisiting and improving szz implementations. In 2019 ACM/IEEE International Symposium on Empirical Software Engineer- ing and Measurement (ESEM), Sep 2019

    2019

  13. [21]

    Frances E. Allen. Control flow analysis. ACM SIGPLAN Notices , page 1–19, Jul 1970

    1970

  14. [22]

    Ottenstein, and Joe D

    Jeanne Ferrante, Karl J. Ottenstein, and Joe D. Warren. The program dependence graph and its use in optimization. ACM Transactions on Programming Languages and Systems , page 319–349, Jun 1987

    1987

  15. [23]

    B.G. Ryder. Constructing the call graph of a program. IEEE Transactions on Software Engineering, page 216–226, May 1979

    1979

  16. [24]

    Codebert: A pre-trained model for programming and natural languages

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, and Ming Zhou. Codebert: A pre-trained model for programming and natural languages. In Findings of the Association for Computa- tional Linguistics: EMNLP 2020...

    2020

  17. [25]

    Attention is all you need

    A Vaswani. Attention is all you need. Advances in Neural Informa- tion Processing Systems, 2017

    2017

  18. [26]

    Bert: Pre-training of deep bidirectional transformers for language understanding

    Jacob Devlin. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018

    2018 arXiv

  19. [27]

    Electra: Pre-training text encoders as discriminators rather than generators

    K Clark. Electra: Pre-training text encoders as discriminators rather than generators. arXiv preprint arXiv:2003.10555, 2020

    2003 arXiv

  20. [28]

    Semi-supervised classification with graph convolutional networks

    Thomas Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv: Learning,arXiv: Learn- ing, Sep 2016

    2016

  21. [29]

    David Duvenaud, Dougal Maclaurin, Jorge Aguilera-Iparraguirre, Rafael G ´omez-Bombarelli, Timothy Hirzel, Al ´an Aspuru-Guzik, and RyanP . Adams. Convolutional networks on graphs for learn- ing molecular fingerprints. arXiv: Learning,arXiv: Learning , Sep 2015

    2015

  22. [30]

    Scarselli, M

    F. Scarselli, M. Gori, Ah Chung Tsoi, M. Hagenbuchner, and G. Monfardini. The graph neural network model. IEEE Trans- actions on Neural Networks, page 61–80, Jan 2009

    2009

  23. [31]

    Understanding the difficulty of training deep feedforward neural networks

    Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the thirteenth international conference on artificial intelligence and statis- tics, pages 249–256. JMLR Workshop and Conference Proceedings, 2010

    2010

  24. [32]

    ChristopherJ.C. Burges. From ranknet to lambdarank to lamb- damart: An overview. Jun 2010

    2010

  25. [33]

    Focal loss for dense object detection

    T Lin. Focal loss for dense object detection. arXiv preprint arXiv:1708.02002, 2017

    2017 arXiv

  26. [34]

    Are automated debugging techniques actually helping programmers? In Proceedings of the 2011 International Symposium on Software Testing and Analysis , Jul 2011

    Chris Parnin and Alessandro Orso. Are automated debugging techniques actually helping programmers? In Proceedings of the 2011 International Symposium on Software Testing and Analysis , Jul 2011

    2011

  27. [35]

    Speech recognition with deep recurrent neural networks

    Alex Graves, Abdel-rahman Mohamed, and Geoffrey Hinton. Speech recognition with deep recurrent neural networks. In 2013 IEEE International Conference on Acoustics, Speech and Signal Processing, May 2013

    2013

  28. [36]

    Locating the security patches for disclosed oss vulnerabilities with vulnerability-commit correlation ranking

    Xin Tan, Yuan Zhang, Chenyuan Mi, Jiajun Cao, Kun Sun, Yifan Lin, and Min Yang. Locating the security patches for disclosed oss vulnerabilities with vulnerability-commit correlation ranking. In Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Securi...

    2021

  29. [37]

    Estimation of prediction error by using k-fold cross-validation

    Tadayoshi Fushiki. Estimation of prediction error by using k-fold cross-validation. Statistics and Computing, page 137–146, Apr 2011

    2011

  30. [38]

    Albert: A lite bert for self-supervised learning of language representations

    Z Lan. Albert: A lite bert for self-supervised learning of language representations. arXiv preprint arXiv:1909.11942, 2019

    1909 arXiv

  31. [39]

    Distilbert, a distilled version of bert: Smaller, faster, cheaper and lighter

    V Sanh. Distilbert, a distilled version of bert: Smaller, faster, cheaper and lighter. arXiv preprint arXiv:1910.01108, 2019

    1910 arXiv

  32. [40]

    Roberta: A robustly optimized bert pretraining ap- proach

    Yinhan Liu. Roberta: A robustly optimized bert pretraining ap- proach. arXiv preprint arXiv:1907.11692, 2019. IEEE TRANSACTIONS ON CONSUMER ELECTRONICS 15

    1907 arXiv

  33. [41]

    Graph Attention Networks , page 39–41

    Zhiyuan Liu and Jie Zhou. Graph Attention Networks , page 39–41. Jan 2020

    2020

  34. [42]

    Human pose prediction using interpretable graph convolutional network for smart home

    Boyu Yang, Liyazhou Hu, Yuyang Peng, Tingting Wang, Xiaofen Fang, Lina Wang, and Kai Fang. Human pose prediction using interpretable graph convolutional network for smart home. IEEE Transactions on Consumer Electronics, 70(1):876–888, 2024

    2024

  35. [43]

    Fcgcn: Feature correlation graph convolution network for few-shot individual identification

    Zhongming Feng, Haoran Zha, Congan Xu, Yuanzhi He, and Yun Lin. Fcgcn: Feature correlation graph convolution network for few-shot individual identification. IEEE Transactions on Consumer Electronics, 2023

    2023

  36. [44]

    Relational graph attention networks

    Dan Busbridge, Dane Sherburn, Pietro Cavallo, and Nils Y Ham- merla. Relational graph attention networks. arXiv preprint arXiv:1904.05811, 2019

    1904 arXiv

  37. [45]

    Deepergcn: All you need to train deeper gcns

    Guohao Li, Chenxin Xiong, Ali Thabet, and Bernard Ghanem. Deepergcn: All you need to train deeper gcns. arXiv preprint arXiv:2006.07739, 2020

    2006 arXiv

  38. [46]

    Addressing imbalance in multi-label classification using weighted cross entropy loss function

    Mohammad Reza Rezaei-Dastjerdehei, Amirmohammad Mijani, and Emad Fatemizadeh. Addressing imbalance in multi-label classification using weighted cross entropy loss function. In 2020 27th national and 5th international iranian conference on biomedical engineering (ICBME), pages ...

    2020

  39. [47]

    Gradient harmonized single-stage detector

    Buyu Li, Yu Liu, and Xiaogang Wang. Gradient harmonized single-stage detector. In Proceedings of the AAAI conference on artificial intelligence, volume 33, pages 8577–8584, 2019

    2019

  40. [48]

    Binary cross entropy with deep learning technique for image classification

    Usha Ruby and Vamsidhar Yendapalli. Binary cross entropy with deep learning technique for image classification. Int. J. Adv. Trends Comput. Sci. Eng, 9(10), 2020

    2020

  41. [49]

    W. E. Wong, C. Parnin, H. Finkel, J. Hummel, and M. Scully. Regression testing and bug fixing: The relationship between test and fault localization. In Proceedings of the 32nd International Conference on Software Engineering (ICSE) , pages 210–219. ACM, 2010

    2010

  42. [50]

    Genprog: A generic method for automatic software repair

    Claire Le Goues, ThanhVu Nguyen, Stephanie Forrest, and West- ley Weimer. Genprog: A generic method for automatic software repair. Ieee transactions on software engineering, 38(1):54–72, 2011

    2011

Pith tools

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