A Unified Model for Cross-Domain Clone Detection via Model Merging

Banani Roy; Chanchal K. Roy; Kevin A. Schneider; Palash R. Roy

REVIEW 3 major objections 6 minor 74 references

A Unified Model for Cross-Domain Clone Detection via Model Merging

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

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

Pith's one-line read Specialists merged on a shared base beat single-domain clone detectors

desk verdict Solid empirical study of model merging for code clone detection; the same-base merging claim holds up in-lab, and the main caveat—untested heterogeneous specialists—is acknowledged and not a fatal flaw. read the letter →

arxiv 2608.04215 v1 pith:WMKH3PCE submitted 2026-08-04 cs.SE cs.AI

Palash R. Roy , Banani Roy , Kevin A. Schneider , Chanchal K. Roy This is my paper · ORCID

classification cs.SEcs.AI

keywords codeclonedetectionmodelmergingtaskvectorsTIEScross-domaingeneralizationout-of-distributionrobustnessdeeplearningfor

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

Code clone detectors trained on one domain—same-language, cross-language, or AI-generated—collapse when tested on another, with F1 drops of 44–72%. This paper asks whether existing specialist models can be unified into one cross-domain detector without retraining or accessing training data, and answers yes through model merging. Its central claim is that specialists fine-tuned from the same pre-trained base can be merged with the TIES algorithm to produce a detector that recovers 93% of multi-task training performance while generalizing up to four times better to unseen AI-generated clones. The practical message is that a team with several domain-specific detectors can combine them by fine-tuning one shared base model per domain and merging the checkpoints, with no training data needed at the merge step.

What carries the argument

The load-bearing object is the task vector, the difference between a fine-tuned specialist's parameters and its pre-trained base. TIES merging operates on these vectors in three steps—trim small updates, elect a majority sign per parameter, and merge only the agreeing updates—so it needs no training data, gradients, or retraining. The paper's same-base hypothesis states that task vectors only align when specialists share the same pre-trained base, and the geometric evidence (cosine similarity and sign agreement between task vectors) is the mechanism that explains why same-base merging succeeds and cross-base merging fails.

What would settle it

Fine-tune two UniXcoder specialists, one on BigCloneBench and one on CLCDSA, with deliberately mismatched training conditions (different learning rates, batch sizes, epoch counts, and data orderings), then merge with TIES. If the combined F1 falls from the reported 0.865 toward the cross-base level of about 0.703, the paper's same-base guarantee would not survive realistic heterogeneous training.

Watch

Extended reading notes

Core claim

The paper's central discovery is that the shared pre-trained base, not the merging algorithm, determines whether specialist detectors can be combined. When two specialists are fine-tuned from the same base (UniXcoder), their task vectors—the parameter differences from the base—show modest but meaningful directional agreement (cosine similarity 0.032, sign agreement 59.5%), and TIES merging turns them into a single model reaching 0.865 combined F1, 93% of multi-task training's 0.927 without any training data at the merge step. When specialists come from different bases (CodeBERT, GraphCodeBERT, UniXcoder), their task vectors are near-orthogonal (cosine similarity 0.001, sign agreement 50.4%) and every merging method yields marginal, high-variance results. The same-base TIES merge also outperforms two zero-shot instruction-tuned code LLMs on GPT-generated clones (0.609 vs. 0.454 F1) at orders of magnitude lower inference cost, while multi-task training collapses on that benchmark (0.151 F1).

Load-bearing premise

The recipe is only demonstrated when every specialist is fine-tuned with identical hyperparameters, training budgets, and preprocessing; if independently trained specialists with mismatched settings do not align well enough for TIES sign election, the same-base advantage could shrink or disappear.

Editorial extensions

If this is right

Teams can build a cross-domain clone detector by fine-tuning one shared base model per domain and merging with TIES, with the merge step running in under five minutes on a CPU and needing no training data.
New clone types (e.g., AI-generated clones) can be added incrementally by fine-tuning another copy of the same base and re-merging, without retaining previous training data.
Merged encoder detectors beat zero-shot instruction-tuned code LLMs on GPTCloneBench while being orders of magnitude cheaper per pair, making them practical for repository-scale or CI workflows.
The same-base compatibility principle should transfer to other software-engineering tasks where domain specialists fail out of distribution, such as vulnerability detection and code summarization, because the failure mode is geometric rather than method-specific.

Reading between the lines

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

The paper leaves untested whether specialists trained by different teams with mismatched settings still merge well; a natural follow-up is a heterogeneous-training study, and this is an inference, not a claim of the paper.
The WUDI-versus-TIES in-distribution/OOD trade-off suggests method choice should depend on deployment priorities; extending this to an adaptive per-layer selection rule is a testable idea beyond the paper.
The failure of linear cross-tokenizer alignment points toward nonlinear alignment as a possible way to relax the shared-base requirement; the paper's own geometry results suggest the barrier is semantic, so a contrastive approach is a plausible next step.
The emergent predictions (samples only the merged model handles) imply new decision boundaries; a concrete extension is to check whether those samples cluster in rare clone families.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Desk Editor's Note

read the letter

For your desk: this is one of the first systematic looks at model merging for code clone detection, and the core claim survives contact with the paper. Same-base parameter merging—TIES in particular—builds a cross-domain detector that reaches 0.865 combined F1 on UniXcoder, roughly 93% of multi-task performance, with no training data at the merge step. That result is backed by three seeds, two model families, and five task-vector methods, and the geometric explanation (cosine similarity 0.032 vs 0.001, sign agreement 59.5% vs 50.4%) is plausible and consistent with the empirical pattern.

The genuinely new bits are: the same-base vs cross-base compatibility boundary is shown to be method-independent (it holds across TIES, WUDI, PCB, etc.); the WUDI/TIES in-distribution vs OOD tradeoff on GPTCloneBench is a real and practically relevant finding; and the negative results on architecture merging and cross-tokenizer alignment are useful for anyone trying to build unified detectors. The paper also earns credit for comparing against multi-task training and two zero-shot code LLMs, and for being unusually honest in Section 8.

The main soft spot is exactly the one the stress-test note raises: the recipe is only demonstrated with specialists trained in one lab under identical hyperparameters, preprocessing, and early stopping. The paper acknowledges this and defers heterogeneous-specialist experiments to future work. That is a real scope limitation, but not a load-bearing flaw. The central claim is an in-lab empirical result, and the paper's own caveat is proportionate. What would strengthen the deployment story is one experiment with deliberately mismatched training conditions (different LR, epochs, or data ordering) to see if TIES still holds. As is, the recipe is "proven in the matched setting, unproven beyond it," and the paper says that.

A few smaller things: some cross-base comparisons and simple averaging are single-seed, so treat those as indicative. GPTCloneBench is self-constructed by the same group; the result is still useful, but it is not an independent benchmark. The complementarity analysis showing 839 and 1,758 "emergent" correct predictions is statistically significant but tiny relative to the test set—interesting mechanism evidence, not a big practical win.

Overall, this is a serious, well-designed empirical study. It deserves a full peer review, and the main referee asks should be: run a heterogeneous-specialist experiment, add error bars to the single-seed numbers, and make the replication package inspectable. I'd bring it to our reading group, and I'd cite it if I worked on clone detection or model merging.

Referee Report

3 major / 6 minor

Summary. The paper studies post-hoc model merging for building cross-domain code clone detectors. It evaluates five task-vector merging methods (Task Arithmetic, TIES, DARE-TIES, WUDI, PCB), architecture-level greedy layer stitching, and cross-tokenizer representation alignment across UniXcoder, CodeBERT, and GraphCodeBERT on BigCloneBench, CLCDSA data, and GPTCloneBench. The central empirical finding is that merging specialists fine-tuned from the same pre-trained base (same-base merging) yields strong combined F1 (up to 0.899 with WUDI, 0.865 with TIES on UniXcoder) without access to any training data at the merging step, while cross-base merging gives only marginal, high-variance gains. The paper further reports that TIES-merged detectors generalize better to unseen AI-generated clones than multi-task training and two zero-shot instruction-tuned code LLMs, and it distills a practical recipe: fine-tune one shared base per domain and merge with TIES. The claimed contributions are a systematic empirical study, a geometric explanation for the same-base advantage, and a practical recipe.

Significance. If the results hold, this is a useful contribution to software engineering: it demonstrates a training-data-free way to combine specialist clone detectors, with evidence across two model families and three random seeds, and it identifies shared-base task-vector compatibility as the key binding condition. The study is careful in several respects: it validates the central same-base result on a second model family (CodeBERT), runs three seeds for the key same-base conditions, reports uncertainty, and provides a replication package. The OOD generalization comparison against multi-task training and instruction-tuned LLMs is a valuable addition, and the honest discussion of limitations in Section 8 is commendable. The main limitation is that the practical recipe has not been tested under heterogeneous specialist training conditions, which is directly relevant to the paper's prescriptive claims.

major comments (3)

[Section 6 (Practical Merging Recipe) and Section 8 (Internal validity)] The recipe instructs practitioners to fine-tune one shared base per domain and merge with TIES, and the abstract advertises a 'practical recipe for building cross-domain clone detectors.' However, all same-base specialists in this study are trained with identical hyperparameters, preprocessing, and early stopping (Section 4, Implementation Details), and Section 8 explicitly defers the study of 'more heterogeneous specialists' to future work. The only cross-configuration evidence (UniXcoder vs. CodeBERT) still uses the same matched pipeline within each family. Because TIES relies on sign agreement and trimming of task vectors, specialists trained by different teams with different learning rates, epochs, data orderings, or preprocessing could plausibly produce task vectors that violate these assumptions. This makes the prescriptive claim conditional on a condition that has not been tested. I request either (a) additional experiments where specialist training conditions are deliberately varied (e.g., learning rates, epochs, batch sizes, data order), or (b) a clear reframing of the recipe as applying to the controlled setting, with the heterogeneous case explicitly flagged as an open question in the abstract and contribution list.
[Section 6, Table 8] The geometric explanation for the same-base advantage is based on cosine similarity (0.032 vs. 0.001) and sign agreement (59.5% vs. 50.4%) computed from a single pair of task vectors, with no variance estimate, confidence interval, or significance test. Both cosine values are extremely close to zero, and the sign-agreement difference is only 9.1 percentage points; without repeated measurements (e.g., across the three seeds already used in the merging experiments, or bootstrap over parameter blocks) it is not possible to assess whether this difference is reliable. Since the paper presents this as 'geometric and statistical evidence' (contribution 2), the statistical support should be strengthened or the claim should be softened to a descriptive observation.
[Table 4 and Finding 2] Finding 2 states that 'same-base merging is method-independent and consistently outperforms cross-base merging across all five task-vector methods.' In the cross-base condition, only WUDI and PCB are reported as three-seed means; DARE-TIES, TIES-only, Equal-weights, and UniX-heavy configurations appear to be single-seed runs. Given that cross-base results show high variance (e.g., PCB CLCDSA F1 ±0.122, WUDI ±0.148), single-seed comparisons are not sufficient to support the claim that the cross-base boundary is method-independent. Please either provide multiple seeds for all cross-base configurations or explicitly qualify the claim as resting on single-seed evidence for those methods.

minor comments (6)

[References] Reference [5] is listed as 'Author Anonymous'; in a non-anonymous submission this placeholder should be replaced with the actual replication package citation.
[Section 4, Implementation Details] The TIES trim percentile used in the experiments is not specified in the implementation details; the recipe in Section 6 mentions a 20% trim. Please state the trim percentile in Section 4 for reproducibility.
[Section 3.4] The alignment loss values (e.g., <0.005 for layers 0–6) are reported without a description of the scale; a sentence explaining that these are MSE values on held-out samples would help interpret why they are considered small.
[Figure 3] The Venn diagram counts are not fully defined in the caption or text; please clarify what the regions represent (e.g., counts of correctly classified samples in each area) and add a legend for the purple regions.
[Table 9] The CB-CLCDSA specialist's perfect collapse (0.000 F1 on BCB and GPT) is surprising; the text explains it via near-zero clone probabilities, but it would be helpful to report the task vector norm or prediction distribution to confirm the specialist was not a degenerate all-nonclone model with near-zero task vector.
[Abstract] The abstract says 'F1 drops exceeding 70% across domains'; this is true for UniXcoder-BCB (71%) and UniXcoder-CLCDSA (72%), but CodeBERT's drop is 48%. Consider rephrasing to 'up to 72%' or 'in several cases exceeding 70%' to avoid overgeneralization.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central findings are direct empirical measurements on fixed public benchmarks, not derivations from the claimed inputs.

full rationale

The paper's central claim (Finding 2) is an empirical measurement: same-base TIES merging reaches 0.865 combined F1 on held-out test sets with no training data at the merging step. There is no fitted parameter that is later presented as a prediction; the task-vector methods are fixed algorithms from prior work, and the merged checkpoints are evaluated on held-out BigCloneBench, CLCDSA, and zero-shot GPTCloneBench. The geometric analysis in Section 6 (cosine similarity 0.032 vs. 0.001; sign agreement 59.5% vs. 50.4%) is a post hoc descriptive explanation of measured merge outcomes, not an input to the merge, so it cannot make the result circular. The only self-reference is that GPTCloneBench [2] was constructed by the same research group; it is a fixed public benchmark used exclusively for zero-shot evaluation and is not fitted to the merged models, so under the stated rules it counts as independent evidence rather than circularity. Section 8 explicitly acknowledges the matched-hyperparameter limitation and defers heterogeneous-specialist study; that is a scope limitation, not a circular derivation. No equation in the paper defines a predicted quantity in terms of the fitted result.

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

The paper contributes an empirical comparison, not a derivation, so the ledger is short. The main hand-chosen decisions are equal merging weights and method defaults from prior work; the load-bearing assumptions are correct implementations of prior merging algorithms and the validity of the benchmarks, including the self-built GPTCloneBench.

free parameters (4)

Merging weights lambda_k = 1/K for all specialists
Set equal by hand and not tuned; controls the tradeoff between same-language and cross-language performance in the merged model.
TIES trim percentile (recipe) = 20
Adopted as the TIES default in the practical recipe; affects which parameter updates survive sign election and is not tuned on the code data.
DARE drop probability p = 0.3
Standard DARE-TIES default used in Table 4; affects sparsity of task vectors.
PCB drop rate = 0.1
Standard PCB default from the official implementation; affects parameter competition balancing.

assumptions (4)

domain assumption The implemented TIES, WUDI, PCB, and DARE algorithms match their official releases.
The paper states it follows official implementations for WUDI and PCB, but no code is provided in the preprint for independent verification.
domain assumption GPTCloneBench labels reliably indicate AI-generated semantic clones.
The OOD robustness conclusion depends on this self-constructed benchmark; no label-quality audit is reported.
domain assumption BCB and CLCDSA train and test splits are leakage-free.
Cross-domain scores assume no problem overlap between splits; the paper states the splits but does not independently verify them.
domain assumption Matched hyperparameters across specialists yield task-vector behavior representative of practical deployments.
All specialists use identical training settings, and the paper acknowledges that heterogeneous training might weaken the same-base advantage.

how reviews work

0 comments

Cite this review

Pith. "Pith review of A Unified Model for Cross-Domain Clone Detection via Model Merging." pith.science (2026). https://pith.science/paper/WMKH3PCE

@misc{pith2026260804215,
  author       = {Pith},
  title        = {Pith review of: A Unified Model for Cross-Domain Clone Detection via Model Merging},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WMKH3PCE}},
  note         = {Machine review of arXiv:2608.04215}
}

read the original abstract

The growing diversity of code clone types, from syntactic copies to cross-language semantic clones to AI-generated duplicates, has created a fragmentation crisis in clone detection. Current deep learning detectors are domain specialists that degrade significantly outside their training distribution, with F1 drops exceeding 70% across domains. Deploying multiple specialized models is impractical, yet training a single cross-domain detector requires simultaneous access to all training data. To address this, we investigate model merging, a family of post-hoc techniques that operate solely on trained checkpoints. We evaluate parameter merging with five task-vector methods, architecture merging via greedy layer stitching, and cross-tokenizer alignment across four code models, three benchmarks, and twelve configurations. Same-base TIES merging creates effective cross-domain detectors, validated across two model families and three random seeds, reaching 0.865 combined F1 on UniXcoder, 93% of multi-task performance without any training data at the merging step. WUDI achieves the highest in-distribution combined F1 at 0.899, but TIES generalizes better to unseen AI-generated clones, making it our recommended method. Cross-base merging yields only marginal and high-variance gains across all five methods, indicating that task vector compatibility through a shared pre-trained base is the binding factor for effective merging. Merged detectors also outperform zero-shot code LLMs on GPTCloneBench at lower inference cost and generalize up to 4x better than multi-task training to unseen AI-generated clones, suggesting a trade-off between in-domain performance and OOD robustness. This work provides one of the first systematic empirical studies of model merging for software engineering and a practical recipe for building cross-domain clone detectors.

Figures

Figures reproduced from arXiv: 2608.04215 by the authors.

**Figure 1.** Overview of our four-phase approach. 2 Background Code Clones. Code clones are similar code fragments that arise through copy-paste, independent development, or automated generation [43]. The standard taxonomy [42, 43] ranges from exact copies (Type-1) through renamed (Type-2) and modified (Type-3) fragments to functionally equivalent but syntactically different code (Type-4). Two specialized forms of Type-4 clones… view at source ↗

**Figure 2.** Greedy layer selection for UniXcoder-BCB + [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗

**Figure 3.** Venn diagram of correct predictions per region. [PITH_FULL_IMAGE:figures/full_fig_p009_3.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

74 extracted references · 30 canonical work pages

[1]

Roy, and Tonghao Chen

Farouq Al-Omari, Chanchal K. Roy, and Tonghao Chen. 2020. Semantic- CloneBench: A Semantic Code Clone Benchmark using Crowd-Source Knowledge. InProceedings of the IEEE 14th International Workshop on Software Clones (IWSC). IEEE, 57–63. doi:10.1109/IWSC50091.2020.9047643

arXiv 2020
[2]

Roy, Banani Roy, and Kevin A

Ajmain Inqiad Alam, Palash Ranjan Roy, Farouq Al-Omari, Chanchal K. Roy, Banani Roy, and Kevin A. Schneider. 2023. GPTCloneBench: A comprehensive benchmark of semantic clones and cross-language clones using GPT-3 model and SemanticCloneBench. InProceedings of the IEEE International Conference on Soft- ware Maintenance and Evolution (ICSME). IEEE, 1–13. do...

work page arXiv 2023
[4]

Almatrafi, Fathy Elbouraey Eassa, and Sanaa Abdullah Sharaf

Afnan A. Almatrafi, Fathy Elbouraey Eassa, and Sanaa Abdullah Sharaf. 2025. Code Clone Detection Techniques Based on Large Language Models.IEEE Access 13 (2025), 46136–46146. doi:10.1109/ACCESS.2025.3549780

work page arXiv 2025
[5]

Author Anonymous. 2026. Replication Package: A Unified Model for Cross- Domain Clone Detection via Model Merging. doi:10.5281/zenodo.21209512

work page doi:10.5281/zenodo.21209512 2026
[6]

Lerina Aversano, Luigi Cerulo, and Massimiliano Di Penta. 2007. How Clones are Maintained: An Empirical Study. InProceedings of the 11th European Conference on Software Maintenance and Reengineering, Software Evolution in Complex Software Intensive Systems (CSMR). IEEE Computer Society, 81–90. doi:10.1109/CSMR. 2007.26

doi:10.1109/csmr 2007
[7]

Baxter, Andrew Yahin, Leonardo Mendonça de Moura, Marcelo Sant’Anna, and Lorraine Bier

Ira D. Baxter, Andrew Yahin, Leonardo Mendonça de Moura, Marcelo Sant’Anna, and Lorraine Bier. 1998. Clone Detection Using Abstract Syntax Trees. InPro- ceedings of the International Conference on Software Maintenance (ICSM). IEEE Computer Society, 368–377. doi:10.1109/ICSM.1998.738528

work page arXiv 1998
[8]

David Berend, Xiaofei Xie, Lei Ma, Lingjun Zhou, Yang Liu, Chi Xu, and Jianjun Zhao. 2020. Cats Are Not Fish: Deep Learning Testing Calls for Out-Of-Distribution Awareness. InProceedings of the 35th IEEE/ACM Interna- tional Conference on Automated Software Engineering (ASE). IEEE, 1041–1052. doi:10.1145/3324884.3416609

arXiv 2020
[9]

Runxi Cheng, Feng Xiong, Yongxian Wei, Wanyun Zhu, and Chun Yuan. 2025. Whoever Started the interference Should End It: Guiding Data-Free Model Merg- ing via Task Vectors. InProceedings of the 42nd International Conference on Ma- chine Learning (ICML) (Proceedings of Machine Learning Research, Vol. 267). PMLR / OpenReview.net, 10121–10143. https://proceed...

work page 2025

Show all 74 references

[10]

Michael Crawshaw. 2020. Multi-Task Learning with Deep Neural Networks: A Survey.CoRRabs/2009.09796 (2020), 43 pages. doi:10.48550/arXiv.2009.09796

2020 doi arXiv
[11]

Shihan Dou, Junjie Shan, Haoxiang Jia, Wenhao Deng, Zhiheng Xi, et al. 2023. Towards Understanding the Capability of Large Language Models on Code Clone Detection: A Survey.CoRRabs/2308.01191 (2023), 13 pages. doi:10.48550/ARXIV. 2308.01191

2023 doi arXiv
[12]

Guodong Du, Junlin Lee, Jing Li, Runhua Jiang, Yifei Guo, et al. 2024. Parameter Competition Balancing for Model Merging. InProceedings of the 37th Annual Conference on Neural Information Processing Systems (NeurIPS). 84746–84776. https://doi.org/10.52202/079017-2691

2024 doi
[13]

Xiaohu Du, Ming Wen, Jiahao Zhu, Zifan Xie, et al . 2024. Generalization- Enhanced Code Vulnerability Detection via Multi-Task Instruction Fine-Tuning. InProceedings of the Findings of the Association for Computational Linguistics (ACL) (Findings of ACL, Vol. ACL 2024). Associ...

2024 doi
[14]

William Fedus, Barret Zoph, and Noam Shazeer. 2022. Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity.J. Mach. Learn. Res.23 (2022), 120:1–120:39. https://jmlr.org/papers/v23/21-0998.html

2022
[15]

Siyue Feng, Wenqi Suo, Yueming Wu, Deqing Zou, Yang Liu, and Hai Jin. 2024. Machine Learning is All You Need: A Simple Token-based Approach for Effective Code Clone Detection. InProceedings of the 46th IEEE/ACM International Con- ference on Software Engineering (ICSE). ACM, 22...

2024 doi
[16]

Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, et al. 2020. CodeBERT: A Pre-Trained Model for Programming and Natural Languages. InProceedings of the Findings of the Association for Computational Linguistics (ACL) (Findings of ACL, Vol. EMNLP). Associ...

2020 doi
[17]

M. A. Ganaie, Minghui Hu, Ashwani Kumar Malik, Muhammad Tanveer, and Ponnuthurai N. Suganthan. 2022. Ensemble deep learning: A review.Eng. Appl. Artif. Intell.115 (2022), 105151. doi:10.1016/J.ENGAPPAI.2022.105151

2022
[18]

Daya Guo, Shuai Lu, Nan Duan, Yanlin Wang, Ming Zhou, and Jian Yin. 2022. UniXcoder: Unified Cross-Modal Pre-training for Code Representation. InPro- ceedings of the 60th Annual Meeting of the Association for Computational Linguistics (ACL), Vol. 1: Long Papers. Association fo...

2022 doi
[19]

Daya Guo, Shuo Ren, Shuai Lu, Zhangyin Feng, Duyu Tang, et al. 2021. Graph- CodeBERT: Pre-training Code Representations with Data Flow. InProceedings of the 9th International Conference on Learning Representations, ICLR. OpenRe- view.net, 18 pages. https://openreview.net/forum...

2021
[20]

Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, et al. 2024. DeepSeek- Coder: When the Large Language Model Meets Programming - The Rise of Code Intelligence.CoRRabs/2401.14196 (2024), 23 pages. doi:10.48550/ARXIV.2401. 14196

2024 doi arXiv
[21]

Dan Hendrycks, Xiaoyuan Liu, Eric Wallace, Adam Dziedzic, Rishabh Krishnan, and Dawn Song. 2020. Pretrained Transformers Improve Out-of-Distribution Robustness. InProceedings of the 58th Annual Meeting of the Association for Computational Linguistics (ACL). Association for Com...

2020 doi
[22]

Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, et al
[23]

Gabriel Ilharco, Marco Túlio Ribeiro, Mitchell Wortsman, Ludwig Schmidt, Han- naneh Hajishirzi, and Ali Farhadi. 2023. Editing models with task arithmetic. InProceedings of the 11th International Conference on Learning Representations. OpenReview.net, 31 pages. https://openrev...

2023
[24]

Ryutaro Inoue and Yoshiki Higo. 2024. Improving Accuracy of LLM-based Code Clone Detection U sing Functionally Equivalent Methods. InProceedings of the 22nd IEEE/ACIS International Conference on Software Engineering Research, Man- agement and Applications (SERA). IEEE, 24–27. ...

2024
[25]

Saidur Rahman, Foutse Khomh, and Biruk Asmare Muse

Hadhemi Jebnoun, Md. Saidur Rahman, Foutse Khomh, and Biruk Asmare Muse
[26]

Bowen Jiang, Mitchell Ruffolo, Aaditya Kulkarni, Teia Canini, and Eman Abdullah AlOmar. 2026. A systematic mapping study on the research landscape of LLM- based code clone detection.Inf. Softw. Technol.195 (2026), 108096. doi:10.1016/J. INFSOF.2026.108096

2026
[27]

Lingxiao Jiang, Ghassan Misherghi, Zhendong Su, and Stéphane Glondu. 2007. DECKARD: Scalable and Accurate Tree-Based Detection of Code Clones. In Proceedings of the 29th International Conference on Software Engineering (ICSE). IEEE Computer Society, 96–105. doi:10.1109/ICSE.2007.30

2007 doi
[28]

Xisen Jin, Xiang Ren, Daniel Preotiuc-Pietro, and Pengxiang Cheng. 2023. Data- less Knowledge Fusion by Merging Weights of Language Models. InProceedings of the 11th International Conference on Learning Representations (ICLR). OpenRe- view.net, 19 pages. doi:10.48550/arXiv.2212.09849

2023 doi arXiv
[29]

Toshihiro Kamiya, Shinji Kusumoto, and Katsuro Inoue. 2002. CCFinder: A Multilinguistic Token-Based Code Clone Detection System for Large Scale Source Code.IEEE Trans. Software Eng.28, 7 (2002), 654–670. doi:10.1109/TSE.2002. 1019480

2002 doi
[30]

Barr, and Alberto Bacchelli

Konstantinos Kitsios, Francesco Sovrano, Earl T. Barr, and Alberto Bacchelli. 2025. Detecting Semantic Clones of Unseen Functionality. InProceedings of the 40th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 1312–1324. doi:10.1109/ASE63991.2025.00112

2025
[31]

Jens Krinke and Chaiyong Ragkhitwetsagul. 2022. BigCloneBench Considered Harmful for Machine Learning. InProceedings of the 16th IEEE International Workshop on Software Clones (IWSC). IEEE, 1–7. doi:10.1109/IWSC55060.2022. 00008

2022
[32]

Chunguang Li, Jessada Konpang, Adisorn Sirikham, and Yan Wang. 2025. Nu- anced Code Clone Detection Through LLM-Based Code Revision and AST Graph Modeling.IEEE Access13 (2025), 191024–191036. doi:10.1109/ACCESS.2025. 3628856

2025 doi
[33]

Jia Li, Chongyang Tao, Zhi Jin, Fang Liu, Jia Li, and Ge Li. 2023. ZC3: Zero-Shot Cross-Language Code Clone Detection. InProceedings of the 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 875–887. doi:10.1109/ASE56229.2023.00210

2023
[34]

Shuai Lu, Daya Guo, Shuo Ren, Junjie Huang, Alexey Svyatkovskiy, Am- brosio Blanco, et al . 2021. CodeXGLUE: A Machine Learning Benchmark Dataset for Code Understanding and Generation. InProceedings of the Neu- ral Information Processing Systems Track on Datasets and Benchmark...

2021
[35]

Michael Matena and Colin Raffel. 2022. Merging Models with Fisher-Weighted Averaging. InProceedings of the Advances in Neural Information Processing Sys- tems 35: Annual Conference on Neural Information Processing Systems (NeurIPS). 14 pages. doi:10.48550/arXiv.2111.09832

2022 doi arXiv
[36]

Mohammed Muqeeth, Haokun Liu, Yufan Liu, and Colin Raffel. 2024. Learning to Route Among Specialized Experts for Zero-Shot Generalization. InProceedings of the 41st International Conference on Machine Learning (ICML) (Proceedings of Machine Learning Research, Vol. 235). PMLR /...

2024
[37]

Roy, and Kevin A

Kawser Wazed Nafi, Tonny Shekha Kar, Banani Roy, Chanchal K. Roy, and Kevin A. Schneider. 2019. CLCDSA: Cross Language Code Clone Detection using Syn- tactical Features and API Documentation. InProceedings of the 34th IEEE/ACM International Conference on Automated Software Eng...

2019
[38]

Tasuku Nakagawa, Yoshiki Higo, and Shinji Kusumoto. 2021. NIL: large-scale detection of large-variance clones. InProceedings of the 29th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering ESEC/FSE. ACM, 830–841. doi:10.1...

2021
[39]

Pham, Jafar M

Hoan Anh Nguyen, Tung Thanh Nguyen, Nam H. Pham, Jafar M. Al-Kofahi, and Tien N. Nguyen. 2009. Accurate and Efficient Structural Characteristic Feature Extraction for Clone Detection. InProceedings of the Fundamental Approaches to Software Engineering, 12th International Confe...

2009 doi
[40]

Van Nguyen, Xingliang Yuan, Tingmin Wu, Surya Nepal, Marthie Grobler, and Carsten Rudolph. 2024. Deep Learning-Based Out-of-distribution Source Code Data Identification: How Far Have We Gone?CoRRabs/2404.05964 (2024), 16 pages. doi:10.48550/ARXIV.2404.05964

2024 doi arXiv
[41]

Daniel Perez and Shigeru Chiba. 2019. Cross-language clone detection by learning over abstract syntax trees. InProceedings of the 16th International Conference on Mining Software Repositories (MSR). IEEE / ACM, 518–528. doi:10.1109/MSR.2019. 00078

2019 doi
[42]

Dhavleesh Rattan, Rajesh Kumar Bhatia, and Maninder Singh. 2013. Software clone detection: A systematic review.Inf. Softw. Technol.55, 7 (2013), 1165–1199. doi:10.1016/J.INFSOF.2013.01.008

2013 doi
[43]

Chanchal Kumar Roy and James R Cordy. 2007. A survey on software clone detection research.Queen’s School of computing TR541, 115 (2007), 64–68. https: //research.cs.queensu.ca/TechReports/Reports/2007-541.pdf

2007
[44]

Chanchal Kumar Roy and James R. Cordy. 2008. NICAD: Accurate Detection of Near-Miss Intentional Clones Using Flexible Pretty-Printing and Code Normal- ization. InProceedings of the 16th IEEE International Conference on Program Com- prehension (ICPC). IEEE Computer Society, 172...

2008 doi
[45]

Palash Roy. 2025. Towards Just-In-Time, Inclusive Clone Refactoring. InPro- ceedings of the 41st IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 884–886. doi:10.1109/ICSME64153.2025.00099

2025
[46]

2024.An Exploratory Study on the Roles of LLMs in Code Similarity Detection and Generation

Palash Ranjan Roy. 2024.An Exploratory Study on the Roles of LLMs in Code Similarity Detection and Generation. Master’s thesis. https://harvest.usask.ca/ items/83c21d22-b256-4ff7-8c58-28bd6ecbdfc1

2024
[47]

Roy, and Kevin A

Palash Ranjan Roy, Ajmain Inqiad Alam, Farouq Al-Omari, Banani Roy, Chan- chal K. Roy, and Kevin A. Schneider. 2023. Unveiling the Potential of Large Language Models in Generating Semantic and Cross-Language Clones. InPro- ceedings of the 17th IEEE International Workshop on So...

2023
[48]

Roy, Banani Roy, Chanchal K

Palash R. Roy, Banani Roy, Chanchal K. Roy, and Kevin Schneider. 2026. MergeSE: Post-Hoc Model Merging for Software Engineering Tasks Without Retraining. In Proceedings of the 41st IEEE/ACM International Conference on Automated Software Engineering (ASE). 4 pages. doi:10.1145/...

2026
[49]

Baochen Sun and Kate Saenko. 2016. Deep CORAL: Correlation Alignment for Deep Domain Adaptation. InProceedings of the European Conference on Computer Vision Workshops (ECCV Workshops) (Lecture Notes in Computer Science, Vol. 9915). 443–450. doi:10.1007/978-3-319-49409-8_35

2016 doi
[50]

Islam, Iman Keivanloo, Chanchal Kumar Roy, and Mohammad Mamun Mia

Jeffrey Svajlenko, Judith F. Islam, Iman Keivanloo, Chanchal Kumar Roy, and Mohammad Mamun Mia. 2014. Towards a Big Data Curated Benchmark of Inter- project Code Clones. InProceedings of the 30th IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE...

2014 doi
[51]

Jeffrey Svajlenko and Chanchal Kumar Roy. 2017. Fast and flexible large- scale clone detection with CloneWorks. InProceedings of the 39th Interna- tional Conference on Software Engineering (ICSE). IEEE Computer Society, 27–30. doi:10.1109/ICSE-C.2017.3

2017 doi
[52]

Jeffrey Svajlenko and Chanchal K. Roy. 2021. BigCloneBench. InCode Clone Analysis. Springer Singapore, 93–105. doi:10.1007/978-981-16-1927-4_7

2021 doi
[53]

Chenning Tao, Qi Zhan, Xing Hu, and Xin Xia. 2022. C4: contrastive cross- language code clone detection. InProceedings of the 30th IEEE/ACM Interna- tional Conference on Program Comprehension (ICPC). ACM, 413–424. doi:10.1145/ 3524610.3527911

2022
[54]

Simon Vandenhende, Stamatios Georgoulis, Wouter Van Gansbeke, Marc Proes- mans, Dengxin Dai, and Luc Van Gool. 2022. Multi-Task Learning for Dense Prediction Tasks: A Survey.IEEE Trans. Pattern Anal. Mach. Intell.44, 7 (2022), 3614–3633. doi:10.1109/TPAMI.2021.3054719

2022
[55]

Jindong Wang, Cuiling Lan, Chang Liu, Yidong Ouyang, et al. 2023. Generalizing to Unseen Domains: A Survey on Domain Generalization.IEEE Trans. Knowl. Data Eng.35, 8 (2023), 8052–8072. doi:10.1109/TKDE.2022.3178128

2023
[56]

Wenhan Wang, Ge Li, Bo Ma, Xin Xia, and Zhi Jin. 2020. Detecting Code Clones with Graph Neural Network and Flow-Augmented Abstract Syntax Tree. In Proceedings of the 27th IEEE International Conference on Software Analysis, Evolu- tion and Reengineering (SANER). IEEE, 261–271. ...

2020
[57]

Yuekun Wang, Yuhang Ye, Yueming Wu, Weiwei Zhang, Yinxing Xue, and Yang Liu. 2023. Comparison and Evaluation of Clone Detection Techniques with Different Code Representations. InProceedings of the 45th IEEE/ACM International Conference on Software Engineering (ICSE). IEEE, 332...

2023
[58]

Huihui Wei and Ming Li. 2017. Supervised Deep Features for Software Functional Clone Detection by Exploiting Lexical and Syntactical Information in Source Code. InProceedings of the 26th International Joint Conference on Artificial Intelligence (ijcai). ijcai.org, 3034–3040. d...

2017 doi
[59]

Martin White, Michele Tufano, Christopher Vendome, and Denys Poshyvanyk
[60]

Mitchell Wortsman, Gabriel Ilharco, Samir Yitzhak Gadre, Rebecca Roelofs, Raphael Gontijo Lopes, et al . 2022. Model soups: averaging weights of mul- tiple fine-tuned models improves accuracy without increasing inference time. InProceedings of the International Conference on M...

2022
[61]

Yueming Wu, Deqing Zou, Shihan Dou, Siru Yang, et al . 2020. SCDetector: Software Functional Clone Detection Based on Semantic Tokens Analysis. In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 821–833. doi:10.1145/3324...

2020
[62]

Zhiwei Xu, Shaohua Qiang, Dinghong Song, Min Zhou, et al . 2024. DSFM: Enhancing Functional Code Clone Detection with Deep Subtree Interactions. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering (ICSE). ACM, 221:1–221:12. doi:10.1145/3597503.3639215

2024
[63]

Raffel, and Mohit Bansal

Prateek Yadav, Derek Tam, Leshem Choshen, Colin A. Raffel, and Mohit Bansal
[64]

Yanming Yang, Xing Hu, Zhipeng Gao, et al. 2024. Federated Learning for Soft- ware Engineering: A Case Study of Code Clone Detection and Defect Prediction. IEEE Trans. Software Eng.50, 2 (2024), 296–321. doi:10.1109/TSE.2023.3347898

2024
[65]

Le Yu, Bowen Yu, Haiyang Yu, Fei Huang, and Yongbin Li. 2024. Language Models are Super Mario: Absorbing Abilities from Homologous Models as a Free Lunch. InProceedings of the 41st International Conference on Machine Learning (ICML) (Proceedings of Machine Learning Research, V...

2024
[66]

Jian Zhang, Xu Wang, Hongyu Zhang, Hailong Sun, Kaixuan Wang, and Xudong Liu. 2019. A novel neural source code representation based on abstract syntax tree. InProceedings of the 41st International Conference on Software Engineering (ICSE). IEEE / ACM, 783–794. doi:10.1109/ICSE...

2019
[67]

Zixian Zhang and Takfarinas Saber. 2025. Exploring the Boundaries Between LLM Code Clone Detection and Code Similarity Assessment on Human and AI-Generated Code.Big Data Cogn. Comput.9, 2 (2025), 41. doi:10.3390/ BDCC9020041

2025
[68]

Zhihan Zhang, Wenhao Yu, Mengxia Yu, Zhichun Guo, and Meng Jiang. 2023. A Survey of Multi-task Learning in Natural Language Processing: Regarding Task Relatedness and Training Methods. InProceedings of the 17th Conference of the European Chapter of the Association for Computat...

2023 doi
[69]

Gang Zhao and Jeff Huang. 2018. DeepSim: deep learning code functional similar- ity. InProceedings of the 2018 ACM Joint Meeting on European Software Engineering Conference and Symposium on the Foundations of Software Engineering (ESEC/FSE). ACM, 141–151. doi:10.1145/3236024.3236068

2018
[70]

Yu Zhou, Xingyu Wu, Jibin Wu, Liang Feng, and KC Tan. 2025. HM3: Hierarchical Multi-Objective Model Merging for Pretrained Models. InProceedings of the Advances in Neural Information Processing Systems 38: Annual Conference on Neural Information Processing Systems (NeurIPS). 3...

2025 doi arXiv
[1037]

doi:10.1109/ASE.2019.00099

2019
[2016]

InProceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering (ASE)

Deep learning code fragments for code clone detection. InProceedings of the 31st IEEE/ACM International Conference on Automated Software Engineering (ASE). ACM, 87–98. doi:10.1145/2970276.2970326
[2022]

Clones in deep learning code: what, where, and why?Empir. Softw. Eng. 27, 4 (2022), 84. doi:10.1007/S10664-021-10099-X

2022 doi
[2023]

InPro- ceedings of the Advances in Neural Information Processing Systems 36: An- nual Conference on Neural Information Processing Systems (NeurIPS)

TIES-Merging: Resolving Interference When Merging Models. InPro- ceedings of the Advances in Neural Information Processing Systems 36: An- nual Conference on Neural Information Processing Systems (NeurIPS). 23 pages. doi:10.52202/075280-0310

doi
[2024]

doi:10.48550/arXiv.2409.12186

Qwen2.5-Coder Technical Report.CoRRabs/2409.12186 (2024), 32 pages. doi:10.48550/arXiv.2409.12186

2024 doi arXiv

Pith tools

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

[1] [1]

Roy, and Tonghao Chen

Farouq Al-Omari, Chanchal K. Roy, and Tonghao Chen. 2020. Semantic- CloneBench: A Semantic Code Clone Benchmark using Crowd-Source Knowledge. InProceedings of the IEEE 14th International Workshop on Software Clones (IWSC). IEEE, 57–63. doi:10.1109/IWSC50091.2020.9047643

arXiv 2020

[2] [2]

Roy, Banani Roy, and Kevin A

Ajmain Inqiad Alam, Palash Ranjan Roy, Farouq Al-Omari, Chanchal K. Roy, Banani Roy, and Kevin A. Schneider. 2023. GPTCloneBench: A comprehensive benchmark of semantic clones and cross-language clones using GPT-3 model and SemanticCloneBench. InProceedings of the IEEE International Conference on Soft- ware Maintenance and Evolution (ICSME). IEEE, 1–13. do...

work page arXiv 2023

[3] [4]

Almatrafi, Fathy Elbouraey Eassa, and Sanaa Abdullah Sharaf

Afnan A. Almatrafi, Fathy Elbouraey Eassa, and Sanaa Abdullah Sharaf. 2025. Code Clone Detection Techniques Based on Large Language Models.IEEE Access 13 (2025), 46136–46146. doi:10.1109/ACCESS.2025.3549780

work page arXiv 2025

[4] [5]

Author Anonymous. 2026. Replication Package: A Unified Model for Cross- Domain Clone Detection via Model Merging. doi:10.5281/zenodo.21209512

work page doi:10.5281/zenodo.21209512 2026

[5] [6]

Lerina Aversano, Luigi Cerulo, and Massimiliano Di Penta. 2007. How Clones are Maintained: An Empirical Study. InProceedings of the 11th European Conference on Software Maintenance and Reengineering, Software Evolution in Complex Software Intensive Systems (CSMR). IEEE Computer Society, 81–90. doi:10.1109/CSMR. 2007.26

doi:10.1109/csmr 2007

[6] [7]

Baxter, Andrew Yahin, Leonardo Mendonça de Moura, Marcelo Sant’Anna, and Lorraine Bier

Ira D. Baxter, Andrew Yahin, Leonardo Mendonça de Moura, Marcelo Sant’Anna, and Lorraine Bier. 1998. Clone Detection Using Abstract Syntax Trees. InPro- ceedings of the International Conference on Software Maintenance (ICSM). IEEE Computer Society, 368–377. doi:10.1109/ICSM.1998.738528

work page arXiv 1998

[7] [8]

David Berend, Xiaofei Xie, Lei Ma, Lingjun Zhou, Yang Liu, Chi Xu, and Jianjun Zhao. 2020. Cats Are Not Fish: Deep Learning Testing Calls for Out-Of-Distribution Awareness. InProceedings of the 35th IEEE/ACM Interna- tional Conference on Automated Software Engineering (ASE). IEEE, 1041–1052. doi:10.1145/3324884.3416609

arXiv 2020

[8] [9]

Runxi Cheng, Feng Xiong, Yongxian Wei, Wanyun Zhu, and Chun Yuan. 2025. Whoever Started the interference Should End It: Guiding Data-Free Model Merg- ing via Task Vectors. InProceedings of the 42nd International Conference on Ma- chine Learning (ICML) (Proceedings of Machine Learning Research, Vol. 267). PMLR / OpenReview.net, 10121–10143. https://proceed...

work page 2025