Pith. sign in

REVIEW 3 major objections 5 minor 34 references

AST-Enhanced or AST-Overloaded? The Surprising Impact of Hybrid Graph Representations on Code Clone Detection

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

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

Pith's one-line read This paper claims that for code clone detection, the GNN architecture matters more than enriching the AST with semantic edges, since a graph-matching model (GMN) is most accurate even on plain AST.

desk verdict Useful ablation matrix with a broken train/test split; the GMN-is-best finding is not trustworthy as reported. read the letter →

arxiv 2506.14470 v1 pith:2ESCK4ZU submitted 2025-06-17 cs.AI cs.SE

Zixian Zhang , Takfarinas Saber This is my paper · ORCID
classification cs.AIcs.SE
keywords codeclonedetectiongraphneuralnetworksrepresentationhybridgraphsabstractsyntaxtreeGMNBigBenchempiricalstudy
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 runs a controlled comparison of AST-based code representations—plain AST, AST plus control-flow edges, data-flow edges, and flow-augmented ASTs—across four graph neural network architectures for clone detection, using a balanced and filtered version of BigCloneBench. The central result is that no single representation is best: GCN and GAT improve when CFG and DFG edges are added, FA-AST generally hurts performance, especially for GGNN, and the Graph Matching Network (GMN) achieves the highest precision and near-best recall even on plain AST. The authors conclude that cross-code similarity computation in the model architecture contributes more than the extra semantic edges. The paper also quantifies overhead: DFG generation costs about 21 times more than AST alone, and FA edges roughly double storage and graph density.

What carries the argument

The central object is the Graph Matching Network (GMN), a GNN whose propagation layer shares messages between the two input graphs so that each node's representation is conditioned on the other graph's nodes; the paper implements this layer following Wang et al. The comparison is carried by four propagation architectures (GCN, GAT, GGNN, GMN) under identical embeddings, pooling, and training, with five edge-type combinations built on the AST. The efficiency analysis uses graph density, generation cost, storage cost, and inference time to quantify what the extra edges buy.

What would settle it

Re-run the comparison on the released splits after checking for overlapping code-fragment IDs between training and test pairs, then retrain all four GNNs on a fragment-disjoint split; if GMN's plain-AST precision (reported as 0.986) and its F1 margin over GCN and GAT drop materially, the conclusion that architecture outweighs enrichment does not survive contamination-free evaluation.

Watch

Extended reading notes

Core claim

The paper claims that the marginal value of enriching an AST with semantic edges depends on the GNN architecture, and that for the strongest model, GMN, enrichment is largely unnecessary. Across BigCloneBench, AST+CFG+DFG consistently raises F1 for GCN and GAT, but FA-AST edges—the flow-augmented structure introduced by Wang et al.—tend to add structural noise and dilute performance, most clearly for GGNN. GMN, whose graph-matching propagation compares node neighborhoods across the two code fragments, reaches its best precision with plain AST and an F1 within 0.001 of the best hybrid, indicating that the architecture's similarity computation matters more than semantic graph augmentation.

Load-bearing premise

The load-bearing premise is that the 80/10/10 split keeps code fragments disjoint between training and test; if the same function appears in both sides, the model has seen test structure during training, and the reported F1 scores—especially GMN's—are inflated.

Editorial extensions

If this is right

  • For practitioners, plain AST with GMN is a lightweight default: near-optimal accuracy with lower storage and faster generation than enriched graphs.
  • For GCN and GAT users, AST+CFG+DFG is the best-value hybrid because CFG and DFG add complementary semantic signal without the overhead of FA edges.
  • FA-AST's high density and storage cost (roughly double AST) rarely justify its performance, especially for recurrent architectures like GGNN.
  • Architecture search may matter more than representation engineering: a model with the capacity to match structures can substitute for handcrafted semantic edges.
  • Resource-constrained clone detectors can skip DFG generation if the roughly 21-fold generation cost is instead spent on a matching-capable architecture.

Reading between the lines

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

  • Our inference: if the train/test split is not fragment-disjoint, the reported absolute F1 scores and GMN's margin over other models are likely inflated; re-testing on a leakage-free split is needed before taking the architecture-over-representation conclusion as quantitative.
  • Our inference: the result suggests a testable design principle—direct cross-code comparison mechanisms are a substitute for handcrafted semantic edges, so a transformer with cross-attention over ASTs might match GMN's performance and would extend the finding beyond GNNs.
  • Our inference: graph density alone is a poor predictor of detection quality, since FA raises density to 0.0202 yet often lowers F1; future representation design should target edge-type informativeness per unit of density.
  • Our inference: the 21x generation cost for DFG is dominated by backward data-dependency tracking, so a batched or incremental extraction algorithm could materially improve the efficiency trade-off without changing detection accuracy.
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

3 major / 5 minor

Summary. The paper reports an empirical study of AST-based hybrid graph representations (AST alone, AST+CFG, AST+DFG, AST+CFG+DFG, and FA-AST combinations) for code clone detection, evaluated across four GNN architectures (GCN, GAT, GGNN, GMN) on BigCloneBench. It reports precision, recall, F1, and computational-overhead metrics, and its headline claims are that AST+CFG+DFG consistently helps convolution- and attention-based models, FA-AST edges often hurt performance, and GMN outperforms the other architectures even with a plain AST, reducing the need for enriched structures.

Significance. If the experimental evidence were reliable, this would be a useful systematic benchmark: it compares representations and architectures under a shared implementation, quantifies overhead, and provides an open-source resource for follow-up work. However, the current evidence has a likely train/test fragment-leakage problem, no repeated-run or significance analysis, and a simplified CFG/DFG construction, so the headline conclusions are not currently supported. The research question is worth answering, but the manuscript needs a substantially more rigorous evaluation before its claims can be accepted.

major comments (3)
  1. [IV.F and Table I] The train/test split is described only as "The dataset is divided into training (80%), validation (10%), and testing (10%) sets," and the sentence before Table I states that "the 8,876 code fragments were paired to form labeled positive and negative clone pairs used across training, validation, and test sets." Table I lists 8,876 code fragments in the training row and gives no fragment counts for validation or testing. This indicates that the same code fragment can appear in both training and test pairs. Since GNNs are trained directly on graph structures, a model such as GMN that performs cross-graph matching can benefit from having seen a fragment's structure during training, inflating the reported F1 values and the "GMN outperforms" conclusion. The authors must either split at the fragment level, assigning all pairs containing a given fragment to the same split, or explicitly report and justify any overlap, and then rerun all experiments under a fragment-disjoint split.
  2. [V.A and Table II] All results in Table II are reported as single precision/recall/F1 values with no multiple seeds, confidence intervals, or significance tests, despite several headline differences being very small—for example, GMN's F1 on AST is 0.953 and on AST+FA+CFG is 0.954, and GGNN's AST, AST+CFG, and AST+DFG all round to 0.900. The claims that "FA often degrades performance" and that "GMN outperforms others" depend on differences that may be within run-to-run noise. The authors should repeat each configuration with several seeds, report variance, and apply an appropriate multiple-comparison procedure when ranking representations and architectures.
  3. [IV.C] The CFG and DFG are not constructed with standard program-analysis algorithms but by heuristic AST traversal: control edges are added based on "execution order of statements" and data edges by a backward scan for a "nearest dominating definition along the AST traversal path." This is a particular simplified edge-augmentation scheme, not a standard CFG or DFG, so the conclusions about "AST+CFG+DFG" may not generalize to the flow graphs used in the cited prior work (e.g., [4], [10]). The authors should either use or cite an established CFG/DFG extractor and validate the constructions, or explicitly reposition the findings as being about their heuristic edge additions rather than about CFG/DFG.
minor comments (5)
  1. [V.A.1] The sentence "we conducted an empirical evaluation across four GNNs architectures: GMN, GCN, GAT and GMN" lists GMN twice; the second occurrence should be GGNN.
  2. [Figure 2] The bottom panel label "GMT" appears to be a typo for "GMN".
  3. [Table I] Table I is visually misaligned: the "Average Number of Line of Codes" and pair counts are not clearly associated with the correct rows, and the validation/test fragment counts are missing.
  4. [IV.A] The classification threshold sigma in Eq. (1) is called "fixed" but its value is never reported; please state it or give the specific reference where it is defined.
  5. [References] Reference [16] is the same paper as [15] (Li et al., Gated Graph Sequence Neural Networks); the duplicate should be merged, and the typo "SwA V" in Section III should be "SwAV."

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: the paper's conclusions are empirical measurements drawn from its own benchmark tables, not derivations from fitted inputs or self-cited premises.

full rationale

This is an empirical comparison study, not a formal derivation. The central claims—that AST+CFG+DFG helps GCN and GAT, that FA-AST often harms performance, and that GMN performs best even with plain AST—are all read directly from reported Precision, Recall, and F1-score measurements in Table II and related figures. There is no equation that defines a prediction in terms of the fitted data, no parameter fitted to a subset and then reported as a prediction on a closely related quantity, and no result that is true by construction. The only self-adjacent citation is the reference to Wang et al. [5] for flow-augmented AST construction, but that is an external prior work used as a baseline methodology, not a load-bearing self-citation. The possible train/test split issue (clone-pair-level splitting without explicit disjoint code fragments) is a validity threat that could inflate absolute numbers, but it is not circularity: the reported numbers are measurements rather than quantities made equal to their inputs by definition. The paper does not invoke a uniqueness theorem, does not smuggle an ansatz through citation, and does not rename a known result as a new derivation. Accordingly, the appropriate circularity score is 0.

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

The central claims rest on standard GNN machinery plus several unverified domain assumptions. The most consequential is the pair-level split assumption, since fragment leakage would directly inflate the reported F1 values. The classification threshold and uniform hyperparameter set are hand-chosen and affect all numbers. No novel theoretical entities are introduced.

free parameters (2)
  • Classification threshold sigma = Not specified in the paper (described only as a fixed threshold)
    Similarity scores are binarized to clone/non-clone using a fixed sigma per Eq. 1. The value is not reported, yet it directly determines precision, recall, and F1. It is hand-chosen and affects all reported metrics.
  • Model hyperparameters (learning rate, weight decay, batch size, embedding dimension, layer count, epochs) = 5e-4, 1e-4, 32, 100, 4, 20
    A single manually chosen configuration is applied to all models. This is a reasonable fairness choice, but the comparison is sensitive to these settings and no per-model tuning is reported.
assumptions (5)
  • domain assumption BigCloneBench clone labels, clone types, and similarity scores are correct ground truth.
    The evaluation trusts the benchmark annotations; no verification or manual audit of labels is performed.
  • domain assumption Merging the balanced subset (Wei and Li) with the original BigCloneBench by fragment IDs restores the correct metadata without introducing errors.
    Section IV.B describes the merge in one sentence; alignment correctness is assumed.
  • domain assumption Javalang's AST extraction is an accurate syntactic representation of Java functions.
    ASTs are the base representation for all studied graphs; errors in extraction would propagate to every experiment.
  • domain assumption The simplified CFG and DFG construction methods (traversal-based control edges and nearest-definition backward tracking) faithfully represent control and data flow.
    Section IV.C describes these constructions at a high level; no validation against standard CFG/DFG frameworks is provided.
  • domain assumption The fixed train/validation/test pair split does not leak identical code fragments across splits.
    Section IV.F states only the split percentages, not the unit of split. Table I lists a fragment count only for training, suggesting pair-level splitting that may leave fragments shared between train and test.

how reviews work

0 comments
Cite this review

Pith. "Pith review of AST-Enhanced or AST-Overloaded? The Surprising Impact of Hybrid Graph Representations on Code Clone Detection." pith.science (2026). https://pith.science/paper/2ESCK4ZU

@misc{pith2026250614470,
  author       = {Pith},
  title        = {Pith review of: AST-Enhanced or AST-Overloaded? The Surprising Impact of Hybrid Graph Representations on Code Clone Detection},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/2ESCK4ZU}},
  note         = {Machine review of arXiv:2506.14470}
}
read the original abstract

As one of the most detrimental code smells, code clones significantly increase software maintenance costs and heighten vulnerability risks, making their detection a critical challenge in software engineering. Abstract Syntax Trees (ASTs) dominate deep learning-based code clone detection due to their precise syntactic structure representation, but they inherently lack semantic depth. Recent studies address this by enriching AST-based representations with semantic graphs, such as Control Flow Graphs (CFGs) and Data Flow Graphs (DFGs). However, the effectiveness of various enriched AST-based representations and their compatibility with different graph-based machine learning techniques remains an open question, warranting further investigation to unlock their full potential in addressing the complexities of code clone detection. In this paper, we present a comprehensive empirical study to rigorously evaluate the effectiveness of AST-based hybrid graph representations in Graph Neural Network (GNN)-based code clone detection. We systematically compare various hybrid representations ((CFG, DFG, Flow-Augmented ASTs (FA-AST)) across multiple GNN architectures. Our experiments reveal that hybrid representations impact GNNs differently: while AST+CFG+DFG consistently enhances accuracy for convolution- and attention-based models (Graph Convolutional Networks (GCN), Graph Attention Networks (GAT)), FA-AST frequently introduces structural complexity that harms performance. Notably, GMN outperforms others even with standard AST representations, highlighting its superior cross-code similarity detection and reducing the need for enriched structures.

Figures

Figures reproduced from arXiv: 2506.14470 by the authors.

Figure 1
Figure 1. Methodology Employed in Our Study. ies in this domain have been tool-based, focusing on evaluating the performance of specific clone detection tools [12], [12], [18]–[20]. Recent research has explored the impact of different code representations on clone detection performance. Wang et al. [21] reproduce 12 clone detection algorithms categorized into text-based, token-based, tree-based, and graph-based ap￾proaches, r… view at source ↗
Figure 2
Figure 2. E. Evaluation Metrics We use multiple evaluation metrics to assess the effective￾ness of different AST-based hybrid graph representations in code clone detection. These metrics include Precision, Recall, and F1-score. To complement accuracy-based evaluation, we report four additional metrics to assess the efficiency and structural properties of each graph representation: Generation Cost, Storage Cost, Average Graph … view at source ↗
Figure 2
Figure 2. Code Clone Detection Pipeline with the Considered GNNs: GCN, GAT, and GGNN (Top Figure); GMN (Bottom [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figures from the paper (3 more)
Figure 3
Figure 3. Figure 3: AST-based Hybrid Code Representation of the sample [PITH_FULL_IMAGE:figures/full_fig_p008_3.png]
Figure 4
Figure 4. Figure 4: Relative F1-score Improvement Achieved By Alternatively Introducing the Representations CFG, DFG, or FA to Other [PITH_FULL_IMAGE:figures/full_fig_p009_4.png]
Figure 5
Figure 5. Figure 5: Performance Comparison Across Various GNNs. [PITH_FULL_IMAGE:figures/full_fig_p009_5.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

34 extracted references · 28 canonical work pages

  1. [21]

    Comparison and evaluation of clone detection techniques with different code representa- tions,

    Y . Wang, Y . Ye, Y . Wu, W. Zhang, Y . Xue, and Y . Liu, “Comparison and evaluation of clone detection techniques with different code representa- tions,” in 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 2023, pp. 332–344

    work page 2023

  2. [22]

    Evaluation of contrastive learning with various code representations for code clone detection,

    M. Zubkov, E. Spirin, E. Bogomolov, and T. Bryksin, “Evaluation of contrastive learning with various code representations for code clone detection,” arXiv preprint arXiv:2206.08726 , 2022

    arXiv 2022

  3. [4]

    Learning graph-based code representations for source-level functional similarity detection,

    J. Liu, J. Zeng, X. Wang, and Z. Liang, “Learning graph-based code representations for source-level functional similarity detection,” in 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE). IEEE, 2023, pp. 345–357

    work page 2023

  4. [10]

    Improving cross- language code clone detection via code representation learning and graph neural networks,

    N. Mehrotra, A. Sharma, A. Jindal, and R. Purandare, “Improving cross- language code clone detection via code representation learning and graph neural networks,” IEEE Transactions on Software Engineering , 2023

    work page 2023

  5. [1]

    Code clones: Detection and management,

    N. Saini, S. Singh et al. , “Code clones: Detection and management,” Procedia computer science , vol. 132, pp. 718–727, 2018

    work page 2018

  6. [2]

    Fowler, Refactoring: improving the design of existing code

    M. Fowler, Refactoring: improving the design of existing code . Addison-Wesley Professional, 2018

    work page 2018

  7. [3]

    A systematic literature review on the use of machine learning in code clone research,

    M. Kaur and D. Rattan, “A systematic literature review on the use of machine learning in code clone research,” Computer Science Review , vol. 47, p. 100528, 2023

    work page 2023

  8. [5]

    Detecting code clones with graph neural network and flow-augmented abstract syntax tree,

    W. Wang, G. Li, B. Ma, X. Xia, and Z. Jin, “Detecting code clones with graph neural network and flow-augmented abstract syntax tree,” in 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER) . IEEE, 2020, pp. 261–271

    work page 2020

Show all 34 references
  1. [6]

    Functional code clone detection with syntax and semantics fusion learning,

    C. Fang, Z. Liu, Y . Shi, J. Huang, and Q. Shi, “Functional code clone detection with syntax and semantics fusion learning,” in Proceedings of the 29th ACM SIGSOFT international symposium on software testing and analysis, 2020, pp. 516–527

    2020

  2. [7]

    A code clone detection algorithm based on graph convolution network with ast tree edge,

    Z. Lu, R. Li, H. Hu, and W.-a. Zhou, “A code clone detection algorithm based on graph convolution network with ast tree edge,” in 2021 IEEE 21st International Conference on Software Quality, Reliability and Security Companion (QRS-C) . IEEE, 2021, pp. 1027–1032

    2021

  3. [8]

    Precise learning of source code contextual semantics via hierarchical dependence structure and graph attention networks,

    Z. Zhao, B. Yang, G. Li, H. Liu, and Z. Jin, “Precise learning of source code contextual semantics via hierarchical dependence structure and graph attention networks,” Journal of Systems and Software , vol. 184, p. 111108, 2022

    2022

  4. [9]

    Sccd-gan: An enhanced semantic code clone detection model using gan,

    K. Xu and Y . Liu, “Sccd-gan: An enhanced semantic code clone detection model using gan,” in 2021 IEEE 4th International Conference on Electronics and Communication Engineering (ICECE). IEEE, 2021, pp. 16–22

    2021

  5. [11]

    Cross-language code clone detection using abstract syntax tree and graph neural network,

    Z. Swilam, A. Hamdy, and A. Pester, “Cross-language code clone detection using abstract syntax tree and graph neural network,” in 2023 International Conference on Computer and Applications (ICCA). IEEE, 2023, pp. 1–5

    2023

  6. [12]

    Investigating the generalizability of deep learning-based clone detectors,

    E. Choi, N. Fuke, Y . Fujiwara, N. Yoshida, and K. Inoue, “Investigating the generalizability of deep learning-based clone detectors,” in 2023 IEEE/ACM 31st International Conference on Program Comprehension (ICPC). IEEE, 2023, pp. 181–185

    2023

  7. [13]

    Semi-supervised classification with graph convolutional networks,

    T. N. Kipf and M. Welling, “Semi-supervised classification with graph convolutional networks,” in International Conference on Learning Rep- resentations (ICLR), 2017

    2017

  8. [14]

    Graph attention networks,

    P. Veli ˇckovi´c, G. Cucurull, A. Casanova, A. Romero, P. Li `o, and Y . Bengio, “Graph attention networks,” in International Conference on Learning Representations, 2018

    2018

  9. [15]

    Gated graph sequence neural networks,

    Y . Li, D. Tarlow, M. Brockschmidt, and R. Zemel, “Gated graph sequence neural networks,” arXiv preprint arXiv:1511.05493 , 2015

    2015 arXiv

  10. [16]

    Gated graph sequence neural networks,

    ——, “Gated graph sequence neural networks,” in Proceedings of the International Conference on Learning Representations (ICLR) , 2016

    2016

  11. [17]

    Java code clone detec- tion by exploiting semantic and syntax information from intermediate code-based graph,

    D. Yuan, S. Fang, T. Zhang, Z. Xu, and X. Luo, “Java code clone detec- tion by exploiting semantic and syntax information from intermediate code-based graph,” IEEE Transactions on Reliability, vol. 72, no. 2, pp. 511–526, 2022

    2022

  12. [18]

    Evaluating clone detection tools with bigclonebench,

    J. Svajlenko and C. K. Roy, “Evaluating clone detection tools with bigclonebench,” in 2015 IEEE international conference on software maintenance and evolution (ICSME) . IEEE, 2015, pp. 131–140

    2015

  13. [19]

    Bigcloneeval: A clone detection tool evaluation framework with bigclonebench,

    ——, “Bigcloneeval: A clone detection tool evaluation framework with bigclonebench,” in 2016 IEEE international conference on software maintenance and evolution (ICSME) . IEEE, 2016, pp. 596–600

    2016

  14. [20]

    Clone detection in test code: an empirical evaluation,

    B. van Bladel and S. Demeyer, “Clone detection in test code: an empirical evaluation,” in 2020 IEEE 27th International Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 2020, pp. 492–500

    2020

  15. [23]

    Efficient transformer with code token learner for code clone detection,

    A. Zhang, L. Fang, C. Ge, P. Li, and Z. Liu, “Efficient transformer with code token learner for code clone detection,” Journal of Systems and Software, vol. 197, p. 111557, 2023

    2023

  16. [24]

    Towards a big data curated benchmark of inter-project code clones,

    J. Svajlenko, J. F. Islam, I. Keivanloo, C. K. Roy, and M. M. Mia, “Towards a big data curated benchmark of inter-project code clones,” in 2014 IEEE International Conference on Software Maintenance and Evolution. IEEE, 2014, pp. 476–480

    2014

  17. [25]

    Supervised deep features for software functional clone detection by exploiting lexical and syntactical information in source code

    H. Wei and M. Li, “Supervised deep features for software functional clone detection by exploiting lexical and syntactical information in source code.” in IJCAI, 2017, pp. 3034–3040

    2017

  18. [26]

    Pytorch: An imperative style, high-performance deep learning library,

    A. Paszke, S. Gross, F. Massa, A. Lerer, J. Bradbury, G. Chanan, T. Killeen, Z. Lin, N. Gimelshein, L. Antiga et al. , “Pytorch: An imperative style, high-performance deep learning library,” Advances in neural information processing systems , vol. 32, 2019

    2019

  19. [27]

    Fast graph representation learning with pytorch geometric,

    M. Fey and J. E. Lenssen, “Fast graph representation learning with pytorch geometric,” arXiv preprint arXiv:1903.02428 , 2019

    1903 arXiv

  20. [28]

    2016, google Code Jam https://code.google.com/codejam/contests.html

    2016

  21. [29]

    Influence of contrastive learning on source code plagiarism detection through recursive neural networks,

    M. A. Fokam and R. Ajoodha, “Influence of contrastive learning on source code plagiarism detection through recursive neural networks,” in 2021 3rd International Multidisciplinary Information Technology and Engineering Conference (IMITEC) . IEEE, 2021, pp. 1–6

    2021

  22. [30]

    Learning-based recursive aggregation of abstract syntax trees for code clone detection,

    L. B ¨uch and A. Andrzejak, “Learning-based recursive aggregation of abstract syntax trees for code clone detection,” in 2019 IEEE 26th Inter- national Conference on Software Analysis, Evolution and Reengineering (SANER). IEEE, 2019, pp. 95–104

    2019

  23. [31]

    Combining holistic source code representation with siamese neural networks for detecting code clones,

    S. Patel and R. Sinha, “Combining holistic source code representation with siamese neural networks for detecting code clones,” in IFIP International Conference on Testing Software and Systems . Springer, 2021, pp. 148–159

    2021

  24. [32]

    Transformer-based networks over tree structures for code classification,

    W. Hua and G. Liu, “Transformer-based networks over tree structures for code classification,” Applied Intelligence, vol. 52, no. 8, pp. 8895–8909, 2022

    2022

  25. [33]

    Ast-path based compare-aggregate network for code clone detection,

    H. Liang and L. Ai, “Ast-path based compare-aggregate network for code clone detection,” in 2021 International Joint Conference on Neural Networks (IJCNN). IEEE, 2021, pp. 1–8

    2021

  26. [34]

    Clcd-i: cross-language clone detection by using deep learning with infercode,

    M. A. Yahya and D.-K. Kim, “Clcd-i: cross-language clone detection by using deep learning with infercode,” Computers, vol. 12, no. 1, p. 12, 2023

    2023

Pith tools

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