Pith. sign in

REVIEW 4 major objections 5 minor 119 references

When Fine-Tuning LLMs Meets Data Privacy: An Empirical Study of Federated Learning in LLM-Based Program Repair

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

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

Pith's one-line read Federated fine-tuning of code LLMs can match centralized fine-tuning for program repair while keeping raw code private, and data heterogeneity has negligible impact.

desk verdict Solid first empirical study of federated fine-tuning for LLM-based program repair, but a C++-to-Java train/eval mismatch and single-run results temper the headline claims. read the letter →

arxiv 2412.01072 v1 pith:VHL6BH25 submitted 2024-12-02 cs.SE

Wenqiang Luo , Jacky Wai Keung , Boyang Yang , He Ye , Claire Le Goues , Tegawende F. Bissyande , Haoye Tian , Bach Le This is my paper · ORCID
classification cs.SE
keywords federatedlearningprogramrepairLLMfine-tuningdataheterogeneitynon-IIDQLoRAcodeprivacyEvalRepair-Java
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper argues that companies with proprietary bug-fix data can fine-tune large language models for automated program repair collaboratively, without ever sharing the code itself. In experiments on 1,239 real-world private C++ bug-fix pairs from TutorCode, it compares federated fine-tuning against local fine-tuning, centralized fine-tuning, and the original models across six code LLMs, evaluating on the augmented Java benchmark EvalRepair-Java. The central finding is that federated fine-tuning improves repair capability by up to 16.67% on Top@10 and 18.44% on Pass@10, and that it can match or even beat centralized fine-tuning, which is usually treated as the upper bound. A second finding is that heterogeneous code—varied coding style, complexity, and embeddings—has negligible impact, so even extreme non-IID data distributions still improve bug fixing. The paper reads these results as evidence that privacy-preserving collaboration is practical for LLM-based program repair.

What carries the argument

The carrier of the argument is parameter-efficient federated fine-tuning: clients freeze 4-bit quantized pre-trained weights and train only low-rank QLoRA adapters, which are uploaded to a server, averaged (mainly by FedAvg), and redistributed, so raw code never leaves a client while communication cost is small. To create realistic data heterogeneity, the paper extracts 23 coding-style attributes, measures code complexity by the number of modified hunks between buggy and fixed code, and uses CodeBERT embeddings of natural-language-program pairs, then allocates data to clients via a Dirichlet distribution with concentration parameters 0.1, 0.01, and extreme (one cluster per client). This construction lets the authors compare IID, mild, medium, and extreme non-IID scenarios across six LLMs, and the combination of QLoRA adapters plus FedAvg aggregation is what lets them attribute observed repair gains to federated collaboration rather than to data pooling.

What would settle it

Run the same federated fine-tuning pipeline on TutorCode's C++ data and evaluate on a held-out C++ repair benchmark (e.g., ManyBugs) in addition to EvalRepair-Java; if the gains on C++ are much larger than on Java or the Java gains disappear, the central claim depends on unverified cross-language transfer.

Watch

Extended reading notes

Core claim

On its own terms, the paper reports three findings. First, federated fine-tuning of code LLMs with QLoRA adapters enhances program repair relative to local fine-tuning and the original models, and it rivals centralized fine-tuning, despite never pooling raw data; across six LLMs it achieved maximal gains of 16.67% on Top@10 and 18.44% on Pass@10 on EvalRepair-Java. Second, feature-skewed non-IID data constructed from coding style, code complexity, and code embeddings does not degrade performance compared with IID data; the differences are mostly not statistically significant and, where significant, have negligible effect sizes, and in some cases non-IID distributions outperform IID. Third, among federated algorithms, FedAvg has the best overall Borda-count ranking, while client-side (FedProx), server-side (FedSWA), both-side (FedOPT), and personalized (pFedMe) optimizations each show model-specific strengths and weaknesses, with pFedMe lagging notably.

Load-bearing premise

The fine-tuning data are 1,239 buggy C++ programs, while the evaluation benchmark is Java, so the paper must assume that repair skill learned on C++ transfers to Java; if that transfer is weak, the measured Java gains would not reflect the federated setup's true repair improvement.

Editorial extensions

If this is right

  • Private code owners can jointly fine-tune code LLMs through adapters only, gaining most of the benefit of centralized fine-tuning without sharing source code.
  • Diverse coding styles, complexity levels, and problem domains across clients do not block collaboration; even extreme non-IID splits improve repair capability.
  • Model choice matters: different LLMs fix different bugs (CodeQWen-7B fixed 7 unique bugs, CodeLlama-13B fixed 2), so federated systems may benefit from mixing architectures.
  • Federated algorithm selection should be model-aware: FedAvg is the safest default, but FedOPT and FedSWA beat it on specific LLMs.
  • Personalized federated learning, despite its value in conventional tasks, is currently the weakest option for LLM fine-tuning for program repair.

Reading between the lines

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

  • If heterogeneity is truly negligible, the same adapter-based federated fine-tuning should transfer to other generative code tasks such as comment generation, test generation, and code translation, where feature skew also dominates.
  • The experiments simulate clients on a small number of GPUs; real deployments with hundreds of companies would face partial participation, stragglers, and communication limits that the current study does not exercise.
  • Privacy here is architectural—raw data stays local—but the paper does not analyze whether model updates or adapters can leak training code; adding differential privacy or secure aggregation would be a natural stress test.
  • A same-language replication (C++ fine-tuning evaluated on C++ bugs) would separate genuine repair learning from cross-language transfer and would directly test the weakest assumption.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper presents an empirical study of federated fine-tuning of code LLMs for automated program repair. It fine-tunes six LLMs (CodeLlama-13B, CodeLlama-7B, DeepSeekCoder-7B, WizardCoder-15B, Mistral-7B, CodeQwen-7B) using QLoRA adapters on a private industrial dataset (TutorCode, 1,239 buggy C++ programs) and evaluates the resulting models on the Java-based EvalRepair-Java benchmark. Three research questions are addressed: whether federated fine-tuning improves repair over original, local, and centralized fine-tuning (RQ1); whether code-feature-based heterogeneity (coding style, complexity, embedding) affects repair performance (RQ2); and how different federated algorithms (FedAvg, FedProx, FedSWA, FedOPT, pFedMe) compare (RQ3). The headline findings are that federated fine-tuning outperforms local fine-tuning and often rivals or exceeds centralized fine-tuning, that heterogeneous Non-IID data has negligible impact, and that FedAvg is the most robust algorithm overall.

Significance. If the findings hold, the paper would be a valuable early contribution on privacy-preserving federated fine-tuning for a generative software engineering task, with practical implications for industrial collaboration on proprietary code. The study has notable strengths: it uses a genuinely private industrial dataset (TutorCode), evaluates with an enhanced benchmark (EvalRepair-Java) that expands test cases to 583 per problem to mitigate patch overfitting, covers six LLMs of diverse architectures, and provides a public artifact. However, the central comparisons are currently undermined by a cross-language train/test mismatch (C++ fine-tuning vs. Java evaluation), by unequal training budgets between FL and the local/central baselines, and by missing statistical or sampling details (no n for Pass@k, no repeated runs). These issues are fixable, but without addressing them the paper's main claims are not yet fully supported.

major comments (4)
  1. [Section 4.2, Tables 2–6] The fine-tuning dataset TutorCode consists of 1,239 buggy C++ programs, whereas the evaluation benchmark EvalRepair-Java is Java-based. The paper provides no argument, pilot, or control experiment establishing that repair capabilities learned on C++ transfer to Java, and Section 7 (Threats to Validity) does not list this language mismatch as a threat. Consequently, the reported gains of federated fine-tuning over the original models (e.g., +16.57% Top@10 on Mistral-7B in Table 2) and the RQ2 claim that heterogeneity has negligible impact could reflect cross-lingual code-generation improvements rather than learning of repair patterns. The authors should either evaluate on a same-language benchmark (e.g., fine-tune on Java data or test on C++ repair tasks) or provide explicit evidence that the learned adapters improve Java repair through a mechanism beyond generic code generation.
  2. [Sections 4.5 and 5.1 (Table 2)] The experimental comparison does not control for the number of local update steps. The hyperparameter setup states a maximum of 30 epochs per client and 10 global rounds, while local and centralized fine-tuning are described as using the same 30-epoch budget with no rounds. If 30 epochs are executed per client per round, federated fine-tuning entails up to 300 epochs of local updates per client, i.e., 10 times more training than local or centralized fine-tuning; even with early stopping, the training-effort disparity could explain FL's apparent superiority. The authors should equalize the total number of optimizer steps (or report the effective step counts) across the three settings before attributing the improvement to federated aggregation.
  3. [Section 4.4 and Tables 2–8] Equation (8) defines Pass@k in terms of n, the total number of generated samples, but n is never stated for any experiment; Top@k similarly depends on the number of sampled completions, which is not reported. Without this information the reported percentages cannot be reproduced or meaningfully compared (a Pass@10 computed from n=10 samples is not the same quantity as one computed from n=200). In addition, all results come from a single run, with no variance estimates or confidence intervals, so differences of 2–3% (e.g., CodeQWen-7B FL vs. Central in Table 2) are within the likely noise band and should not be over-interpreted.
  4. [Section 5.2, Table 7] The Wilcoxon signed-rank tests and Cliff's delta values in Table 7 pool across six LLMs and five metrics without stating the sample size or the unit of analysis. This creates non-independence among observations and raises multiple-comparison concerns. The authors should specify which observations enter each test (e.g., per-model, per-metric, per-problem results), the sample size, and whether any correction for multiple testing was applied; otherwise the reported p-values are difficult to interpret.
minor comments (5)
  1. [Section 4.3] The model name '"Mitral-7B"' appears to be a typo for '"Mistral-7B"'; please fix it in the abbreviated names list.
  2. [Section 5.2] The text describing Figure 3b refers to '"TutorLLMCode"', but the dataset is called TutorCode elsewhere; please use a consistent name.
  3. [Section 8] The conclusion states the dataset contains '"1239 programming problems"', while Section 4.2 reports 1,239 buggy programs addressing 35 distinct problems; please align the wording.
  4. [Figure 2] The Venn diagram in Figure 2 has no legend or explanation of the region labels; please clarify what the numbers represent (e.g., numbers of bugs fixed by each model or overlaps).
  5. [Section 4.1 and Section 7] RQ1's title includes '"protecting data privacy"', but the study does not evaluate privacy guarantees (e.g., differential privacy or leakage under inference attacks); consider rephrasing to avoid overclaiming, or add a discussion of the privacy model assumed.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central FL-vs-local-vs-central comparison is measured against an external benchmark lineage, not derived from its own inputs.

full rationale

This paper is an empirical study, not a derivation chain. The central claim (Finding 1, Section 5.1) that federated fine-tuning enhances program repair is supported by evaluation results on EvalRepair-Java, which is built on the external HumanEval-Java and EvalPlus benchmarks with expanded test cases; the improvements are measured, not fitted or constructed from the fine-tuning data. The self-citations to TutorCode [101] and EvalRepair-Java [102] are data and benchmark provenance, not load-bearing theoretical claims: the paper does not invoke a prior uniqueness theorem or ansatz from those works to force its conclusions. RQ2's heterogeneity finding is likewise an empirical comparison of IID vs Non-IID scenarios using Wilcoxon tests and Cliff's delta, so the conclusion that heterogeneity is negligible does not reduce by definition to the way heterogeneity was constructed. The cross-language mismatch (C++ TutorCode fine-tuning, Java EvalRepair-Java evaluation) is a legitimate external-validity threat and could undermine the transfer claim, but it is a question of experimental design, not circularity. No equation or argument in the paper makes the predicted outcome equivalent to its inputs by construction.

Assumptions & free parameters 13 free parameters · 6 assumptions · 0 invented entities

The central claims depend on several domain assumptions about dataset representativeness, benchmark validity, cross-language transfer, and privacy guarantees. The experimental hyperparameters are numerous and chosen by hand, though none are fitted to the evaluation results.

free parameters (13)
  • learning_rate = 1e-4
    Chosen by hand, following prior work (Jiang et al. 2021), affects all training runs.
  • lora_rank = 32
    Chosen hyperparameter for QLoRA; controls adapter capacity.
  • lora_dropout = 0.05
    Chosen hyperparameter for QLoRA.
  • max_epochs_per_client = 30
    At most 30 epochs, with early stopping at 10 epochs without improvement.
  • global_rounds = 10
    Number of federated aggregation rounds.
  • dirichlet_alpha_mild = 0.1
    Concentration parameter for mild Non-IID.
  • dirichlet_alpha_medium = 0.01
    Concentration parameter for medium Non-IID.
  • num_clients_rq1 = 100
    Number of simulated clients in RQ1.
  • num_clients_style = 40
    Matches number of coding style clusters for extreme Non-IID.
  • num_clients_embedding = 45
    Matches number of code embedding clusters.
  • num_clients_complexity = 10
    Based on 10-13 complexity levels, merging high levels.
  • num_clusters_style = 40
    Set according to SSE drop rate for coding style clustering.
  • num_clusters_embedding = 45
    Set according to SSE drop rate for code embedding clustering.
assumptions (6)
  • domain assumption TutorCode dataset is representative of private industrial bug-fix data
    The paper generalizes to real-world industries from this single online programming education dataset (Section 4.2).
  • domain assumption EvalRepair-Java with expanded tests accurately measures patch correctness
    The benchmark is treated as a valid measure of repair capability (Section 4.2).
  • domain assumption Repair capability transfers from C++ fine-tuning to Java evaluation
    Training data is C++, benchmark is Java; this cross-language transfer is assumed without validation (Section 4.2).
  • domain assumption Federated learning without differential privacy or secure aggregation preserves data privacy
    The paper claims privacy from not sharing raw data, but no formal mechanism is implemented (Sections 1, 2.1).
  • domain assumption Feature clustering and Dirichlet allocation simulate real-world heterogeneity
    Constructed Non-IID scenarios are assumed to represent industry diversity (Section 5.2).
  • domain assumption QLoRA adapter aggregation is equivalent to model averaging for the global model
    The paper averages low-rank adapters rather than full model weights (Section 2.1).

how reviews work

0 comments
Cite this review

Pith. "Pith review of When Fine-Tuning LLMs Meets Data Privacy: An Empirical Study of Federated Learning in LLM-Based Program Repair." pith.science (2026). https://pith.science/paper/VHL6BH25

@misc{pith2026241201072,
  author       = {Pith},
  title        = {Pith review of: When Fine-Tuning LLMs Meets Data Privacy: An Empirical Study of Federated Learning in LLM-Based Program Repair},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/VHL6BH25}},
  note         = {Machine review of arXiv:2412.01072}
}
read the original abstract

Software systems have been evolving rapidly and inevitably introducing bugs at an increasing rate, leading to significant losses in resources consumed by software maintenance. Recently, large language models (LLMs) have demonstrated remarkable potential in enhancing software development and maintenance practices, particularly in automated program repair (APR) with improved accuracy and efficiency of bug fixing. However, LLM-based APR heavily relies on high-quality code repositories. A larger portion of existing code repositories are for private use and proprietary assets from various industries, reflecting more diversity and nuances in the data since real-world industries often have more extensive software development practices, which cannot be covered by merely public datasets. Therefore, utilizing private datasets shows significant potential in enhancing software development and maintenance. However, obtaining such data from various industries is hindered by data privacy concerns, as companies are reluctant to share their codebases. To address the gap, we investigate the use of federated learning as a privacy-preserving approach that enables private entities to fine-tune LLMs on proprietary and decentralized data, facilitating the collaboration between clients to fully utilize their data to help enhance software development and maintenance. Our evaluation reveals that federated fine-tuning can effectively enhance program repair capabilities. Notably, the impact of heterogeneous code on LLM fine-tuning is negligible, indicating that real-world industries can benefit from collaborative development regardless of diverse data distributions. Furthermore, each type of federated algorithm exhibits unique strengths across different LLMs, suggesting that fine-tuning for program repair can be enhanced by tailoring the optimization process to specific characteristics of different LLMs.

Figures

Figures reproduced from arXiv: 2412.01072 by the authors.

Figure 1
Figure 1. The workflow of federated learning of parameter-efficient federated fine-tuning framework. 2.2 Data Heterogeneity in Federated Learning Data heterogeneity has been a critical challenge that incurs performance degradation in federated learning [36]. In ideal situations where the data across all clients are independently and identically distributed (IID), federated learning can achieve comparable performance without c… view at source ↗
Figure 2
Figure 2. Bug fix Venn diagram on EvalRepair-Java. The Venn diagram of unique fixes generated by different LLMs with federated fine-tuning is presented in [PITH_FULL_IMAGE:figures/full_fig_p018_2.png] view at source ↗
Figure 3
Figure 3. SSE drop rate for different numbers of clusters [PITH_FULL_IMAGE:figures/full_fig_p021_3.png] view at source ↗
Figures from the paper (7 more)
Figure 4
Figure 4. Figure 4: presents the distribution of the 40 clustered coding styles and the distribution of different code complexity levels represented by the number of modified hunks. As depicted in Figure 4b, there are 13 levels of code complexity since there is no code with 12 modified hu…
Figure 5
Figure 5. Figure 5: presents as an example the four data distributions employed in our study based on the feature of coding style. As we can observe from Figure 5a, the data distributions across clients tend to be identical, whereas the distributions in Figure 5b, Figure 5c, and Figure 5d…
Figure 8
Figure 8. Figure 8: We interpret the three examples as follows: (1) As depicted in Figure 6, the coding style [PITH_FULL_IMAGE:figures/full_fig_p023_8.png]
Figure 6
Figure 6. Figure 6: An example of heterogeneous coding style. Significance Test. Furthermore, we employ Wilcoxon signed-rank test [91] to evaluate the statistical significance of the performance differences between various scenarios, in which the null hypothesis is that there is no signif…
Figure 7
Figure 7. Figure 7: An example of heterogeneous code complexity. # Chasing the Enemy Mr. Garlic’s troops are chasing the enemy ship. When they arrive at island A, the enemy ship has already escaped from the island for n minutes. If the enemy ship ········ Output the number of minutes it t…
Figure 8
Figure 8. Figure 8: An example of heterogeneous code embedding. Effect Size. To further validate the significance of the observed differences and assess the magnitude of the effect, we adopt Cliff’s delta [16], a non-parametric effect size measure. Cliff’s delta has been widely used in re…
Figure 9
Figure 9. Figure 9: The Borda count of different federated algorithms. Finding 7: As the foundational and the most widely applied federated algorithm, FedAvg is rarely optimal in the bug fixing ability across all LLMs, but achieves the best overall performance instead, which demonstrates …

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

119 extracted references · 38 canonical work pages

  1. [1]

    Josh Achiam, Steven Adler, Sandhini Agarwal, Lama Ahmad, Ilge Akkaya, Florencia Leoni Aleman, Diogo Almeida, Janko Altenschmidt, Sam Altman, Shyamal Anadkat, et al. 2023. Gpt-4 technical report. arXiv preprint arXiv:2303.08774 (2023)

    arXiv 2023

  2. [2]

    Toufique Ahmed and Premkumar Devanbu. 2022. Multilingual training for software engineering. In Proceedings of the 44th International Conference on Software Engineering . 1443–1455

    2022

  3. [3]

    Vard Antinyan, Miroslaw Staron, and Anna Sandberg. 2017. Evaluating code complexity triggers, use of complexity measures and the influence of code complexity on maintenance time. Empirical Software Engineering 22 (2017), 3057–3087

    2017

  4. [4]

    Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. 2021. Program synthesis with large language models.arXiv preprint arXiv:2108.07732 (2021)

    arXiv 2021

  5. [5]

    David Azcona, Piyush Arora, I-Han Hsiao, and Alan Smeaton. 2019. user2code2vec: Embeddings for profiling students based on distributional representations of source code. In Proceedings of the 9th International Conference on Learning Analytics & Knowledge. 86–95

    2019

  6. [6]

    Jinze Bai, Shuai Bai, Yunfei Chu, Zeyu Cui, Kai Dang, Xiaodong Deng, Yang Fan, Wenbin Ge, Yu Han, Fei Huang, et al. 2023. Qwen technical report. arXiv preprint arXiv:2309.16609 (2023)

    arXiv 2023

  7. [7]

    Niclas Boehmer, Robert Bredereck, and Dominik Peters. 2023. Rank aggregation using scoring rules. In Proceedings of the AAAI Conference on Artificial Intelligence , Vol. 37. 5515–5523

    2023

  8. [8]

    CO Boulder. 2019. University of cambridge study: Failure to adopt reverse debugging costs global economy $41 billion annually. Google Scholar Google Scholar Reference (2019)

    2019

Show all 119 references
  1. [9]

    Tom Britton, Lisa Jeng, Graham Carver, Paul Cheak, and Tomer Katzenellenbogen. 2013. Reversible debugging software. Judge Bus. School, Univ. Cambridge, Cambridge, UK, Tech. Rep 229 (2013)

    2013

  2. [10]

    Debora Caldarola, Barbara Caputo, and Marco Ciccone. 2022. Improving generalization in federated learning by seeking flat minima. In European Conference on Computer Vision . Springer, 654–672

    2022

  3. [11]

    Aylin Caliskan-Islam, Richard Harang, Andrew Liu, Arvind Narayanan, Clare Voss, Fabian Yamaguchi, and Rachel Greenstadt. 2015. De-anonymizing programmers via code stylometry. In 24th USENIX security symposium (USENIX Security 15). 255–270

    2015

  4. [12]

    Tianshi Che, Ji Liu, Yang Zhou, Jiaxiang Ren, Jiwen Zhou, Victor S Sheng, Huaiyu Dai, and Dejing Dou. 2023. Federated learning of large language models with parameter-efficient prompt tuning and adaptive optimization. arXiv preprint arXiv:2310.15080 (2023)

    2023 arXiv

  5. [13]

    Chaochao Chen, Xiaohua Feng, Jun Zhou, Jianwei Yin, and Xiaolin Zheng. 2023. Federated large language model: A position paper. arXiv preprint arXiv:2307.08925 (2023)

    2023 arXiv

  6. [14]

    Haokun Chen, Ahmed Frikha, Denis Krompass, Jindong Gu, and Volker Tresp. 2023. FRAug: Tackling federated learn- ing with Non-IID features via representation augmentation. In Proceedings of the IEEE/CVF International Conference on Computer Vision. 4849–4859

    2023

  7. [15]

    Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde De Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, et al. 2021. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021)

    2021 arXiv

  8. [16]

    Norman Cliff. 1993. Dominance statistics: Ordinal analyses to answer ordinal questions. Psychological bulletin 114, 3 (1993), 494

    1993

  9. [17]

    Tim Dettmers, Artidoro Pagnoni, Ari Holtzman, and Luke Zettlemoyer. 2024. Qlora: Efficient finetuning of quantized llms. Advances in Neural Information Processing Systems 36 (2024)

    2024

  10. [18]

    Zishuo Ding, Heng Li, Weiyi Shang, and Tse-Hsun Peter Chen. 2022. Can pre-trained code embeddings improve model performance? Revisiting the use of code embeddings in software engineering tasks. Empirical Software Engineering 27, 3 (2022), 63. , Vol. 1, No. 1, Article . Publica...

    2022

  11. [19]

    Zhangyin Feng, Daya Guo, Duyu Tang, Nan Duan, Xiaocheng Feng, Ming Gong, Linjun Shou, Bing Qin, Ting Liu, Daxin Jiang, et al. 2020. Codebert: A pre-trained model for programming and natural languages. arXiv preprint arXiv:2002.08155 (2020)

    2020 arXiv

  12. [20]

    Michael Fu, Chakkrit Tantithamthavorn, Trung Le, Van Nguyen, and Dinh Phung. 2022. VulRepair: a T5-based automated software vulnerability repair. In Proceedings of the 30th ACM joint european software engineering conference and symposium on the foundations of software engineer...

    2022

  13. [21]

    Tianyu Gao, Adam Fisch, and Danqi Chen. 2021. Making Pre-trained Language Models Better Few-shot Learners. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Vol...

    2021 doi

  14. [22]

    Waris Gill, Ali Anwar, and Muhammad Ali Gulzar. 2023. Feddebug: Systematic debugging for federated learning applications. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 512–523

    2023

  15. [23]

    Daya Guo, Qihao Zhu, Dejian Yang, Zhenda Xie, Kai Dong, Wentao Zhang, Guanting Chen, Xiao Bi, Yu Wu, YK Li, et al. 2024. DeepSeek-Coder: When the Large Language Model Meets Programming–The Rise of Code Intelligence. arXiv preprint arXiv:2401.14196 (2024)

    2024 arXiv

  16. [24]

    Sichong Hao, Xianjun Shi, Hongwei Liu, and Yanjun Shu. 2023. Enhancing Code Language Models for Program Repair by Curricular Fine-tuning Framework. In 2023 IEEE International Conference on Software Maintenance and Evolution (ICSME). IEEE, 136–146

    2023

  17. [25]

    Kevin Hsieh, Amar Phanishayee, Onur Mutlu, and Phillip Gibbons. 2020. The non-iid data quagmire of decentralized machine learning. In International Conference on Machine Learning . PMLR, 4387–4398

    2020

  18. [26]

    Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen

  19. [27]

    Jonathan Huang. 2005. Maximum likelihood estimation of Dirichlet distribution parameters. CMU Technique report 76 (2005)

    2005

  20. [28]

    Kai Huang, Xiangxin Meng, Jian Zhang, Yang Liu, Wenjie Wang, Shuhao Li, and Yuqing Zhang. 2023. An empirical study on fine-tuning large language models of code for automated program repair. In2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE) ....

    2023

  21. [29]

    Albert Q Jiang, Alexandre Sablayrolles, Arthur Mensch, Chris Bamford, Devendra Singh Chaplot, Diego de las Casas, Florian Bressand, Gianna Lengyel, Guillaume Lample, Lucile Saulnier, et al. 2023. Mistral 7B. arXiv preprint arXiv:2310.06825 (2023)

    2023 arXiv

  22. [30]

    Jingang Jiang, Xiangyang Liu, and Chenyou Fan. 2023. Low-parameter federated learning with large language models. arXiv preprint arXiv:2307.13896 (2023)

    2023 arXiv

  23. [31]

    Nan Jiang, Kevin Liu, Thibaud Lutellier, and Lin Tan. 2023. Impact of code language models on automated program repair. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 1430–1442

    2023

  24. [32]

    Nan Jiang, Thibaud Lutellier, and Lin Tan. 2021. Cure: Code-aware neural machine translation for automatic program repair. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE) . IEEE, 1161–1173

    2021

  25. [33]

    Matthew Jin, Syed Shahriar, Michele Tufano, Xin Shi, Shuai Lu, Neel Sundaresan, and Alexey Svyatkovskiy. 2023. Inferfix: End-to-end program repair with llms. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Softw...

    2023

  26. [34]

    René Just, Darioush Jalali, and Michael D Ernst. 2014. Defects4J: A database of existing faults to enable controlled testing studies for Java programs. In Proceedings of the 2014 international symposium on software testing and analysis . 437–440

    2014

  27. [35]

    Peter Kairouz, Ziyu Liu, and Thomas Steinke. 2021. The distributed discrete gaussian mechanism for federated learning with secure aggregation. In International Conference on Machine Learning . PMLR, 5201–5212

    2021

  28. [36]

    Peter Kairouz, H Brendan McMahan, Brendan Avent, Aurélien Bellet, Mehdi Bennis, Arjun Nitin Bhagoji, Kallista Bonawitz, Zachary Charles, Graham Cormode, Rachel Cummings, et al . 2021. Advances and open problems in federated learning. Foundations and trends® in machine learning...

    2021

  29. [37]

    Katikapalli Subramanyam Kalyan. 2023. A survey of GPT-3 family large language models including ChatGPT and GPT-4. Natural Language Processing Journal (2023), 100048

    2023

  30. [38]

    Jinkyu Kim, Geeho Kim, and Bohyung Han. 2022. Multi-level branched regularization for federated learning. In International Conference on Machine Learning . PMLR, 11058–11073

    2022

  31. [39]

    Pavneet Singh Kochhar, Xin Xia, David Lo, and Shanping Li. 2016. Practitioners’ expectations on automated fault localization. In Proceedings of the 25th international symposium on software testing and analysis . 165–176

    2016

  32. [40]

    Vladimir Kovalenko, Egor Bogomolov, Timofey Bryksin, and Alberto Bacchelli. 2020. Building implicit vector representations of individual coding style. In Proceedings of the IEEE/ACM 42nd International Conference on Software Engineering Workshops. 117–124. , Vol. 1, No. 1, Arti...

    2020

  33. [41]

    Patrick Kreutzer, Georg Dotzler, Matthias Ring, Bjoern M Eskofier, and Michael Philippsen. 2016. Automatic clustering of code changes. In Proceedings of the 13th International Conference on Mining Software Repositories . 61–72

    2016

  34. [42]

    Weirui Kuang, Bingchen Qian, Zitao Li, Daoyuan Chen, Dawei Gao, Xuchen Pan, Yuexiang Xie, Yaliang Li, Bolin Ding, and Jingren Zhou. 2024. Federatedscope-llm: A comprehensive package for fine-tuning large language models in federated learning. In Proceedings of the 30th ACM SIG...

    2024

  35. [43]

    Jahnavi Kumar and Sridhar Chimalakonda. 2024. Code Summarization without Direct Access to Code-Towards Exploring Federated LLMs for Software Engineering. In Proceedings of the 28th International Conference on Evaluation and Assessment in Software Engineering . 100–109

    2024

  36. [44]

    Xuan-Bach D Le, Lingfeng Bao, David Lo, Xin Xia, Shanping Li, and Corina Pasareanu. 2019. On reliability of patch correctness assessment. In 2019 IEEE/ACM 41st International Conference on Software Engineering (ICSE). IEEE, 524–535

    2019

  37. [45]

    Claire Le Goues, Neal Holtschulte, Edward K Smith, Yuriy Brun, Premkumar Devanbu, Stephanie Forrest, and Westley Weimer. 2015. The ManyBugs and IntroClass benchmarks for automated repair of C programs. IEEE Transactions on Software Engineering 41, 12 (2015), 1236–1256

    2015

  38. [46]

    Qinbin Li, Yiqun Diao, Quan Chen, and Bingsheng He. 2022. Federated learning on non-iid data silos: An experimental study. In 2022 IEEE 38th international conference on data engineering (ICDE) . IEEE, 965–978

    2022

  39. [47]

    Tian Li, Shengyuan Hu, Ahmad Beirami, and Virginia Smith. 2021. Ditto: Fair and robust federated learning through personalization. In International conference on machine learning . PMLR, 6357–6368

    2021

  40. [48]

    Tian Li, Anit Kumar Sahu, Manzil Zaheer, Maziar Sanjabi, Ameet Talwalkar, and Virginia Smith. 2020. Federated optimization in heterogeneous networks. Proceedings of Machine learning and systems 2 (2020), 429–450

    2020

  41. [49]

    Xiaoxiao Li, Meirui Jiang, Xiaofei Zhang, Michael Kamp, and Qi Dou. 2021. Fedbn: Federated learning on non-iid features via local batch normalization. arXiv preprint arXiv:2102.07623 (2021)

    2021 arXiv

  42. [50]

    Zhen Li, Guenevere Chen, Chen Chen, Yayi Zou, and Shouhuai Xu. 2022. Ropgen: Towards robust code authorship attribution via automatic coding style transformation. In Proceedings of the 44th International Conference on Software Engineering. 1906–1918

    2022

  43. [51]

    Zijian Li, Zehong Lin, Jiawei Shao, Yuyi Mao, and Jun Zhang. 2024. Fedcir: Client-invariant representation learning for federated non-iid features. IEEE Transactions on Mobile Computing (2024)

    2024

  44. [52]

    Wentao Liang, Xiang Ling, Jingzheng Wu, Tianyue Luo, and Yanjun Wu. 2023. A Needle is an Outlier in a Haystack: Hunting Malicious PyPI Packages with Code Clustering. In2023 38th IEEE/ACM International Conference on Automated Software Engineering (ASE). IEEE, 307–318

    2023

  45. [53]

    Bo Lin, Shangwen Wang, Ming Wen, and Xiaoguang Mao. 2022. Context-aware code change embedding for better patch correctness assessment. ACM Transactions on Software Engineering and Methodology (TOSEM) 31, 3 (2022), 1–29

    2022

  46. [54]

    Bill Yuchen Lin, Chaoyang He, Zihang Zeng, Hulin Wang, Yufen Huang, Christophe Dupuy, Rahul Gupta, Mahdi Soltanolkotabi, Xiang Ren, and Salman Avestimehr. 2021. Fednlp: Benchmarking federated learning methods for natural language processing tasks. arXiv preprint arXiv:2104.088...

    2021 arXiv

  47. [55]

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

    2024

  48. [56]

    Xiao-Yang Liu, Rongyi Zhu, Daochen Zha, Jiechao Gao, Shan Zhong, Matt White, and Meikang Qiu. 2023. Differentially private low-rank adaptation of large language model using federated learning. ACM Transactions on Management Information Systems (2023)

    2023

  49. [57]

    Ilya Loshchilov and Frank Hutter. 2019. Decoupled Weight Decay Regularization. arXiv:1711.05101 [cs.LG] https://arxiv.org/abs/1711.05101

    2019 arXiv

  50. [58]

    Mi Luo, Fei Chen, Dapeng Hu, Yifan Zhang, Jian Liang, and Jiashi Feng. 2021. No fear of heterogeneity: Classifier calibration for federated learning with non-iid data. Advances in Neural Information Processing Systems 34 (2021), 5972–5984

    2021

  51. [59]

    Ziyang Luo, Can Xu, Pu Zhao, Qingfeng Sun, Xiubo Geng, Wenxiang Hu, Chongyang Tao, Jing Ma, Qingwei Lin, and Daxin Jiang. 2023. Wizardcoder: Empowering code large language models with evol-instruct. arXiv preprint arXiv:2306.08568 (2023)

    2023 arXiv

  52. [60]

    Lucy Ellen Lwakatare, Aiswarya Raj, Ivica Crnkovic, Jan Bosch, and Helena Holmström Olsson. 2020. Large-scale machine learning systems in real-world industrial settings: A review of challenges and solutions. Information and software technology 127 (2020), 106368

    2020

  53. [61]

    Xinge Ma, Jiangming Liu, Jin Wang, and Xuejie Zhang. 2023. FedID: Federated Interactive Distillation for Large-Scale Pretraining Language Models. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. 8566–8577. , Vol. 1, No. 1, Article . Pu...

    2023

  54. [62]

    Ehsan Mashhadi and Hadi Hemmati. 2021. Applying codebert for automated program repair of java simple bugs. In 2021 IEEE/ACM 18th International Conference on Mining Software Repositories (MSR) . IEEE, 505–509

    2021

  55. [63]

    Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. 2017. Communication- efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics. PMLR, 1273–1282

    2017

  56. [64]

    Steinbach Michael. 2000. A comparison of document clustering techniques. In KDD Workshop on Text Mining, 2000

    2000

  57. [65]

    Do-Van Nguyen, Anh-Khoa Tran, and Koji Zettsu. 2022. FedProb: An aggregation method based on feature probability distribution for federated learning on non-IID data. In 2022 IEEE International Conference on Big Data (Big Data) . IEEE, 2875–2881

    2022

  58. [66]

    Yannic Noller, Ridwan Shariffdeen, Xiang Gao, and Abhik Roychoudhury. 2022. Trust enhancement issues in program repair. In Proceedings of the 44th International Conference on Software Engineering . 2228–2240

    2022

  59. [67]

    Rishov Paul, Md Mohib Hossain, Mohammed Latif Siddiq, Masum Hasan, Anindya Iqbal, and Joanna Santos. 2023. Enhancing automated program repair through fine-tuning and prompt engineering. arXiv preprint arXiv:2304.07840 (2023)

    2023 arXiv

  60. [68]

    Norman Peitek, Sven Apel, Chris Parnin, André Brechmann, and Janet Siegmund. 2021. Program comprehension and code complexity metrics: An fmri study. In 2021 IEEE/ACM 43rd International Conference on Software Engineering (ICSE). IEEE, 524–536

    2021

  61. [69]

    Krishna Pillutla, Kshitiz Malik, Abdel-Rahman Mohamed, Mike Rabbat, Maziar Sanjabi, and Lin Xiao. 2022. Federated learning with partial model personalization. In International Conference on Machine Learning . PMLR, 17716–17758

    2022

  62. [70]

    Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konečný, Sanjiv Kumar, and Hugh Brendan McMahan

    Sashank J. Reddi, Zachary Charles, Manzil Zaheer, Zachary Garrett, Keith Rush, Jakub Konečný, Sanjiv Kumar, and Hugh Brendan McMahan. 2021. Adaptive Federated Optimization. In International Conference on Learning Representations. https://openreview.net/forum?id=LkFG3lB13U5

    2021

  63. [71]

    Jörg Rothe. 2019. Borda count in collective decision making: a summary of recent results. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 33. 9830–9836

    2019

  64. [72]

    Baptiste Roziere, Jonas Gehring, Fabian Gloeckle, Sten Sootla, Itai Gat, Xiaoqing Ellen Tan, Yossi Adi, Jingyu Liu, Romain Sauvestre, Tal Remez, et al. 2023. Code llama: Open foundation models for code.arXiv preprint arXiv:2308.12950 (2023)

    2023 arXiv

  65. [73]

    Max Schäfer, Sarah Nadi, Aryaz Eghbali, and Frank Tip. 2023. An empirical evaluation of using large language models for automated unit test generation. IEEE Transactions on Software Engineering (2023)

    2023

  66. [74]

    Shriram Shanbhag and Sridhar Chimalakonda. 2022. Exploring the under-explored terrain of non-open source data for software engineering through the lens of federated learning. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Fou...

    2022

  67. [75]

    André Silva, Sen Fang, and Martin Monperrus. 2023. Repairllama: Efficient representations and fine-tuned adapters for program repair. arXiv preprint arXiv:2312.15698 (2023)

    2023 arXiv

  68. [76]

    Jingwei Sun, Ziyue Xu, Hongxu Yin, Dong Yang, Daguang Xu, Yiran Chen, and Holger R Roth. 2023. Fedbpt: Efficient federated black-box prompt tuning for large language models. arXiv preprint arXiv:2310.01467 (2023)

    2023 arXiv

  69. [77]

    Canh T Dinh, Nguyen Tran, and Josh Nguyen. 2020. Personalized federated learning with moreau envelopes.Advances in neural information processing systems 33 (2020), 21394–21405

    2020

  70. [78]

    Min Tan, Yinfu Feng, Lingqiang Chu, Jingcheng Shi, Rong Xiao, Haihong Tang, and Jun Yu. 2023. FedSea: Federated Learning via Selective Feature Alignment for Non-IID Multimodal Data. IEEE Transactions on Multimedia (2023)

    2023

  71. [79]

    Xueyang Tang, Song Guo, and Jingcai Guo. 2021. Personalized federated learning with contextualized generalization. arXiv preprint arXiv:2106.13044 (2021)

    2021 arXiv

  72. [80]

    Haoye Tian, Xunzhu Tang, Andrew Habib, Shangwen Wang, Kui Liu, Xin Xia, Jacques Klein, and Tegawendé F Bissyandé. 2022. Is this change the answer to that problem? correlating descriptions of bug and code changes for evaluating patch correctness. In Proceedings of the 37th IEEE...

    2022

  73. [81]

    Chih-Kai Ting, Karl Munson, Serenity Wade, Anish Savla, Kiran Kate, and Kavitha Srinivas. 2023. CodeStylist: a system for performing code style transfer using neural networks. In Proceedings of the AAAI Conference on Artificial Intelligence, Vol. 37. 16485–16487

    2023

  74. [82]

    Hugo Touvron, Louis Martin, Kevin Stone, Peter Albert, Amjad Almahairi, Yasmine Babaei, Nikolay Bashlykov, Soumya Batra, Prajjwal Bhargava, Shruti Bhosale, et al. 2023. Llama 2: Open foundation and fine-tuned chat models. arXiv preprint arXiv:2307.09288 (2023)

    2023 arXiv

  75. [83]

    Michele Tufano, Cody Watson, Gabriele Bavota, Massimiliano Di Penta, Martin White, and Denys Poshyvanyk. 2019. An empirical study on learning bug-fixing patches in the wild via neural machine translation. ACM Transactions on Software Engineering and Methodology (TOSEM) 28, 4 (...

    2019

  76. [84]

    Pablo Villalobos, Anson Ho, Jaime Sevilla, Tamay Besiroglu, Lennart Heim, and Marius Hobbhahn. 2024. Position: Will we run out of data? Limits of LLM scaling based on human-generated data. In Forty-first International Conference on Machine Learning. https://openreview.net/foru...

    2024

  77. [85]

    Boxin Wang, Yibo Jacky Zhang, Yuan Cao, Bo Li, H Brendan McMahan, Sewoong Oh, Zheng Xu, and Manzil Zaheer. 2023. Can Public Large Language Models Help Private Cross-device Federated Learning? arXiv preprint arXiv:2305.12132 (2023)

    2023 arXiv

  78. [86]

    Shangwen Wang, Ming Wen, Bo Lin, Hongjun Wu, Yihao Qin, Deqing Zou, Xiaoguang Mao, and Hai Jin. 2020. Automated patch correctness assessment: How far are we?. In Proceedings of the 35th IEEE/ACM International Conference on Automated Software Engineering . 968–980

    2020

  79. [87]

    Yue Wang, Hung Le, Akhilesh Gotmare, Nghi Bui, Junnan Li, and Steven Hoi. 2023. CodeT5+: Open Code Large Language Models for Code Understanding and Generation. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing . 1069–1088

    2023

  80. [88]

    Yuxiang Wei, Chunqiu Steven Xia, and Lingming Zhang. 2023. Copiloting the copilots: Fusing large language models with completion engines for automated program repair. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations...

    2023

  81. [89]

    Cathrin Weiss, Rahul Premraj, Thomas Zimmermann, and Andreas Zeller. 2007. How long will it take to fix this bug?. In fourth international workshop on mining software repositories (MSR’07: ICSE Workshops 2007) . IEEE, 1–1

    2007

  82. [90]

    Eliane S Wiese, Anna N Rafferty, Daniel M Kopta, and Jacqulyn M Anderson. 2019. Replicating novices’ struggles with coding style. In 2019 IEEE/ACM 27th International Conference on Program Comprehension (ICPC) . IEEE, 13–18

    2019

  83. [91]

    Frank Wilcoxon. 1992. Individual comparisons by ranking methods. In Breakthroughs in statistics: Methodology and distribution. Springer, 196–202

    1992

  84. [92]

    Herbert Woisetschläger, Alexander Erben, Shiqiang Wang, Ruben Mayer, and Hans-Arno Jacobsen. 2024. Federated fine-tuning of llms on the very edge: The good, the bad, the ugly. In Proceedings of the Eighth Workshop on Data Management for End-to-End Machine Learning . 39–50

    2024

  85. [93]

    Yonghao Wu, Zheng Li, Jie M Zhang, and Yong Liu. 2024. ConDefects: A Complementary Dataset to Address the Data Leakage Concern for LLM-Based Fault Localization and Program Repair. In Companion Proceedings of the 32nd ACM International Conference on the Foundations of Software ...

    2024

  86. [94]

    Yue Wu, Shuaicheng Zhang, Wenchao Yu, Yanchi Liu, Quanquan Gu, Dawei Zhou, Haifeng Chen, and Wei Cheng

  87. [95]

    Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2022. Practical program repair in the era of large pre-trained language models. arXiv preprint arXiv:2210.14179 (2022)

    2022 arXiv

  88. [96]

    Chunqiu Steven Xia, Yuxiang Wei, and Lingming Zhang. 2023. Automated program repair in the era of large pre-trained language models. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 1482–1494

    2023

  89. [97]

    Chunqiu Steven Xia and Lingming Zhang. 2022. Less training, more repairing please: revisiting automated program repair via zero-shot learning. In Proceedings of the 30th ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering...

    2022

  90. [98]

    Can Xu, Qingfeng Sun, Kai Zheng, Xiubo Geng, Pu Zhao, Jiazhan Feng, Chongyang Tao, and Daxin Jiang. 2023. Wizardlm: Empowering large language models to follow complex instructions. arXiv preprint arXiv:2304.12244 (2023)

    2023 arXiv

  91. [99]

    Runhua Xu, Nathalie Baracaldo, Yi Zhou, Ali Anwar, and Heiko Ludwig. 2019. Hybridalpha: An efficient approach for privacy-preserving federated learning. In Proceedings of the 12th ACM workshop on artificial intelligence and security . 13–23

    2019

  92. [100]

    Aidan ZH Yang, Claire Le Goues, Ruben Martins, and Vincent Hellendoorn. 2024. Large language models for test-free fault localization. In Proceedings of the 46th IEEE/ACM International Conference on Software Engineering . 1–12

    2024

  93. [101]

    Boyang Yang, Haoye Tian, Weiguo Pian, Haoran Yu, Haitao Wang, Jacques Klein, Tegawendé F Bissyandé, and Shunfu Jin. 2024. CREF: an LLM-based conversational software repair framework for programming tutors. In Proceedings of the 33rd ACM SIGSOFT International Symposium on Softw...

    2024

  94. [102]

    Boyang Yang, Haoye Tian, Jiadong Ren, Hongyu Zhang, Jacques Klein, Tegawendé F Bissyandé, Claire Le Goues, and Shunfu Jin. 2024. Multi-Objective Fine-Tuning for Enhanced Program Repair with LLMs. arXiv preprint arXiv:2404.12636 (2024)

    2024

  95. [103]

    Xiyuan Yang, Wenke Huang, and Mang Ye. 2023. Dynamic personalized federated learning with adaptive differential privacy. Advances in Neural Information Processing Systems 36 (2023), 72181–72192

    2023

  96. [104]

    Yanming Yang, Xing Hu, Zhipeng Gao, Jinfu Chen, Chao Ni, Xin Xia, and David Lo. 2024. Federated Learning for Software Engineering: A Case Study of Code Clone Detection and Defect Prediction. IEEE Transactions on Software Engineering (2024)

    2024

  97. [105]

    He Ye, Jian Gu, Matias Martinez, Thomas Durieux, and Martin Monperrus. 2021. Automated classification of overfitting patches with statically extracted code features. IEEE Transactions on Software Engineering 48, 8 (2021), 2920–2938

    2021

  98. [106]

    Wei Yuan, Quanjun Zhang, Tieke He, Chunrong Fang, Nguyen Quoc Viet Hung, Xiaodong Hao, and Hongzhi Yin

  99. [107]

    Linan Yue, Qi Liu, Yichao Du, Weibo Gao, Ye Liu, and Fangzhou Yao. 2023. Fedjudge: Federated legal large language model. arXiv preprint arXiv:2309.08173 (2023)

    2023 arXiv

  100. [108]

    Biao Zhang, Zhongtao Liu, Colin Cherry, and Orhan Firat. 2024. When Scaling Meets LLM Finetuning: The Effect of Data, Model and Finetuning Method. In The Twelfth International Conference on Learning Representations . https: //openreview.net/forum?id=5HCnKDeTws

    2024

  101. [109]

    Quanjun Zhang, Chunrong Fang, Yuxiang Ma, Weisong Sun, and Zhenyu Chen. 2023. A survey of learning-based automated program repair. ACM Transactions on Software Engineering and Methodology 33, 2 (2023), 1–69

    2023

  102. [110]

    Quanjun Zhang, Chunrong Fang, Weisong Sun, Yan Liu, Tieke He, Xiaodong Hao, and Zhenyu Chen. 2024. Appt: Boosting automated patch correctness prediction via fine-tuning pre-trained models. IEEE Transactions on Software Engineering (2024)

    2024

  103. [111]

    Quanjun Zhang, Chunrong Fang, Yang Xie, YuXiang Ma, Weisong Sun, and Yun Yang Zhenyu Chen. 2024. A Systematic Literature Review on Large Language Models for Automated Program Repair. arXiv preprint arXiv:2405.01466 (2024)

    2024

  104. [112]

    Ziqi Zhang, Yuanchun Li, Bingyan Liu, Yifeng Cai, Ding Li, Yao Guo, and Xiangqun Chen. 2023. FedSlice: Protecting Federated Learning Models from Malicious Participants with Model Slicing. In 2023 IEEE/ACM 45th International Conference on Software Engineering (ICSE) . IEEE, 460–472

    2023

  105. [113]

    Jujia Zhao, Wenjie Wang, Chen Xu, Zhaochun Ren, See-Kiong Ng, and Tat-Seng Chua. 2024. Llm-based federated recommendation. arXiv preprint arXiv:2402.09959 (2024)

    2024 arXiv

  106. [114]

    Fei Zheng. 2023. Input reconstruction attack against vertical federated large language models. arXiv preprint arXiv:2311.07585 (2023)

    2023 arXiv

  107. [115]

    Qinkai Zheng, Xiao Xia, Xu Zou, Yuxiao Dong, Shan Wang, Yufei Xue, Lei Shen, Zihan Wang, Andi Wang, Yang Li, et al. 2023. Codegeex: A pre-trained model for code generation with multilingual benchmarking on humaneval-x. In Proceedings of the 29th ACM SIGKDD Conference on Knowle...

    2023

  108. [116]

    Armin Zirak and Hadi Hemmati. 2024. Improving automated program repair with domain adaptation. ACM Transactions on Software Engineering and Methodology 33, 3 (2024), 1–43. , Vol. 1, No. 1, Article . Publication date: December 2024

    2024

  109. [2021]

    arXiv preprint arXiv:2106.09685 (2021)

    Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685 (2021)

    2021 arXiv

  110. [2022]

    In Proceedings of the 31st ACM SIGSOFT international , Vol

    CIRCLE: continual repair across programming languages. In Proceedings of the 31st ACM SIGSOFT international , Vol. 1, No. 1, Article . Publication date: December 2024. 40 Luo et al. symposium on software testing and analysis . 678–690

    2024

  111. [2023]

    In International Conference on Machine Learning

    Personalized federated learning under mixture of distributions. In International Conference on Machine Learning . PMLR, 37860–37879

Pith tools

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