Pith. sign in

REVIEW 4 major objections 5 minor 50 references

Advancing AI-assisted Hardware Design with Hierarchical Decentralized Training and Personalized Inference-Time Optimization

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

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

Pith's one-line read A two-stage framework for LLM-assisted hardware design couples decentralized training with personalized inference-time optimization to improve semantic accuracy by 33-50% and speed generation by 2.3x.

desk verdict A plausible hybrid federated-learning-plus-model-merging recipe for LLM hardware design, with a useful efficiency metric, but the online acceleration claim is untested and the KL objective as written looks mis-specified. read the letter →

arxiv 2506.00002 v1 pith:RJRSI4KM submitted 2025-04-21 cs.AR cs.AIcs.DCcs.LG

Hao Mark Chen , Zehuan Zhang , Wanru Zhao , Nicholas Lane , Hongxiang Fan This is my paper · ORCID
classification cs.ARcs.AIcs.DCcs.LG
keywords LLM-assistedhardwaredesignhigh-levelsynthesisQiskitcodegenerationfederatedlearningmodelmerginginference-timeaccelerationparalleldecodingTrueput
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 targets three obstacles to using large language models for hardware design: too little public training data, uneven data quality, and slow inference. It proposes a two-stage framework. The first stage trains models from private design sources without sharing raw data, using a hierarchy that combines federated learning with model merging and weights client contributions by hardware-specific metrics such as syntax accuracy. The second stage personalizes inference for each client by tuning parallel-decoding tree size, sampling strategy, and sample count around a new efficiency metric called Trueput. If the framework works as claimed, LLM-assisted high-level synthesis and Qiskit quantum program generation become substantially more accurate and faster, bringing automatic hardware design closer to practical use.

What carries the argument

The load-bearing object is the two-tier hierarchical training pipeline: Tier 1 runs federated learning inside communication-reliable groups and local training for isolated clients, and Tier 2 merges all resulting models with DARE using syntax accuracy as the aggregation weight. On the inference side, the framework is carried by Trueput, defined as Pass@k divided by expected inference latency, which the paper models as (1-(1-p)^k)/Tinf(k) and uses to show a finite optimal sample count k per GPU budget. Acceleration is provided by parallel multi-token decoding, with client acceleration parameters fit online by minimizing the difference between the accelerated distribution and the target model distribution during deployment. The machinery works because hardware generation, unlike free-form code, has objective quality metrics (syntax, functional correctness, latency) that can serve as aggregation weights and as the objective for Trueput optimization.

What would settle it

Take the deployed framework with the learned acceleration parameters, serve a fixed set of HLS or Qiskit prompts, and log both the distance between the accelerated and original token distributions and the pass@k of the generated designs while holding tree size fixed. If that distance does not decrease over traffic, or if pass@k drops below greedy decoding once the learned parameters are active, then the deployment-time personalization contribution is not carrying the reported 2.3x speedup and quality gains.

Watch

Extended reading notes

Core claim

The paper's central claim is that a two-stage recipe can make LLM-based hardware generation practical. In stage one, a hierarchical decentralized training scheme splits clients into groups with reliable communication that run federated learning, plus isolated clients that train locally, and then merges the resulting models with syntax-accuracy-weighted model merging. In stage two, clients personalize inference by choosing a parallel-decoding tree size and sampling configuration and by optimizing the number of generated samples against the Trueput metric, defined as Pass@k divided by inference latency. On an HLS benchmark the hierarchical approach reports roughly an 80% accuracy gain over the unfine-tuned model and about 50% over plain model merging; on a Qiskit benchmark it matches a centrally trained baseline. Personalized inference-time optimization reports a 2.3x speedup and up to 46% syntax-accuracy improvement over greedy decoding, with the optimal tree size and sample number varying with client compute resources.

Load-bearing premise

The paper assumes that during deployment, user requests can serve as labels for learning the multi-token acceleration parameters, and that keeping the accelerated model's predictions close to the original model's predictions preserves generation quality; no experiment measures this learning, its convergence, or its effect on pass rate.

Editorial extensions

If this is right

  • Organizations can collaborate on LLM hardware-generation models without exposing proprietary design code, using syntax accuracy as a quality filter during aggregation.
  • LLM-based HLS and Qiskit generation could see 33-50% semantic accuracy gains and 2.3x faster inference, making practical deployment more realistic.
  • The Trueput analysis gives a principled way to choose the sample count per client, and the optimal count shifts with GPU capacity, so per-client tuning is justified.
  • The speedup and accuracy improvements are orthogonal to existing scaffolding such as retrieval-augmented generation and multi-agent verification, so they can stack on top of those methods.
  • Central communication cost in collaborative training drops from O(N*R) transfers to O(G + N_L), easing cross-organization participation.

Reading between the lines

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

  • The same decentralized-plus-personalized recipe is likely to transfer to Verilog/RTL generation and other structured hardware-adjacent code tasks, since those tasks also have checkable syntax and functional-correctness metrics; the paper does not test this.
  • Trueput is a general efficiency metric for any batched generative code task, not just hardware, so the finite-optimal-k analysis could be reused in software code generation; the paper only applies it to HLS and Qiskit.
  • The online learning of acceleration parameters is the least evidenced component, so a direct measurement of convergence and pass rate under live traffic would either validate the deployment-time personalization story or show that only the preconfigured tree-size tuning carries the speedup.
  • If the hierarchical training claim extends to larger client counts, the framework offers a path to foundation-model training for hardware that does not require a central high-bandwidth server, but scaling behavior beyond the 40-client simulation is untested.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. This paper proposes a two-stage framework for LLM-assisted hardware design generation. Stage 1 is a hierarchical decentralized training scheme that combines federated learning for clients with reliable communication and local training for isolated parties, followed by model merging, with user-defined hardware metrics (syntax accuracy, correctness, latency) used for aggregation weights. Stage 2 introduces personalized inference-time optimizations: a new efficiency metric called Trueput, defined as Pass@k divided by inference latency; customized sampling strategies; and an online learning scheme for multi-token parallel-decoding acceleration parameters. The authors evaluate the framework on an HLS benchmark with CodeLlama-7B (MachineEval and a 50-sample HumanEval split) and a Qiskit benchmark with StarCoder2-3B, reporting large syntax/semantic accuracy gains for the hierarchical approach and up to a 2.3x inference speedup with parallel decoding. They also report that Trueput has a finite optimal sample count under a fixed GPU budget.

Significance. If the results hold, the framework is a practical and broadly applicable recipe for using private, heterogeneous hardware-design data without centralizing it, and the release of code and benchmarks would be a useful community resource. The central idea of using hardware-specific quantitative metrics for decentralized aggregation is well motivated, and the reported accuracy gains over the base model and model merging are large. The paper also makes a genuinely useful point that sampling strategies and decode-tree sizes should be personalized per client and per compute budget, and the Trueput metric gives a simple way to reason about that trade-off. However, the paper's significance is currently limited by missing validation of the online inference-acceleration learning component, by the lack of a central fine-tuning baseline for HLS, and by the absence of statistical rigor on very small test sets.

major comments (4)
  1. [Sec. V-B] The online learning of acceleration parameters phi is a load-bearing contribution, but it is never evaluated. No experiment in Section VI trains phi, measures the KL objective, or reports convergence; the reported 2.3x speedup in Fig. 5 comes from sweeping a fixed tree size, and the text states that the optimal configuration is determined offline. In addition, the objective arg min_phi KL(Pa || Po) is suspect: since Po is the fixed target distribution being approximated, the standard objective would be the forward KL KL(Po || Pa) or the cross-entropy of target samples under Pa, whereas the reverse KL is mode-seeking and is not what user-generated deployment outputs would naturally provide. The authors should either evaluate this learning scheme directly or remove the online-learning claim and present the parallel-decoding optimization as offline personalization of tree size.
  2. [Sec. VI-A and Sec. VI-B, Figs. 3-4] The HLS experiments compare the hierarchical method to the base model and to model merging, but not to centralized fine-tuning on the same HLS training data. The Qiskit section asserts that the hierarchical model is comparable to a centrally trained baseline [4] without showing that baseline in any figure or table. Without a central fine-tuning baseline, the results cannot establish that Stage 1's hierarchical decentralized training adds value over standard fine-tuning, which is a central claim of the paper. I request this baseline for both HLS and Qiskit, with the same evaluation protocol.
  3. [Sec. VI-A, Figs. 3-6] The quantitative claims rest on a 50-sample HumanEval set and a 50-sample Qiskit test set, and the paper reports no random seeds, no error bars, and no training hyperparameters such as learning rate, LoRA rank, number of epochs, number of communication rounds, or merge-recipe details. At least three seeds with standard deviations should be reported for the main figures, and the small test sets should be accompanied by confidence intervals or bootstrap estimates. As written, the headline accuracy and speedup numbers cannot be assessed for stability.
  4. [Sec. VI-B, Fig. 3] The textual summary of Fig. 3 is quantitatively imprecise. From Fig. 3a, syntax accuracy rises from 52.15% to 91.18% (a 39.03 percentage-point increase, or about 74.8% relative), and from Fig. 3b, syntax accuracy rises from 12% to 92%; the claimed 'nearly an 80% increase' and 'approximately 50% over the model obtained through model merging' are not literally what the bars show. Please restate the numbers in the text or annotate the figure so the central comparison is unambiguous.
minor comments (5)
  1. [Sec. VI-D, Fig. 5] The sentence 'In Fig. 5, we examine how different sampling strategies affect syntax accuracy' is immediately preceded by another sentence beginning 'In Fig. 5'; please label the panels (e.g., left and right) to make clear which result refers to which panel.
  2. [Sec. V-A, Eq. (2)] The expression 1 - (1 - p)^k is the probability of at least one success under independent draws, not the unbiased Pass@k estimator of Codex, which accounts for sampling without replacement from a finite set of generated samples; please clarify which quantity is being used in the Trueput analysis.
  3. [References] Reference [4] appears to have an invalid arXiv identifier (2504.6375344); please correct or update it.
  4. [Sec. VI-B] The phrase 'with template generation enhancement' is not defined anywhere in the paper; please describe this enhancement or remove the phrase.
  5. [Algorithm 1] Statement 17 of Algorithm 1 has formatting and notation issues in the set union; please clean up the presentation so the notation is consistent with the definitions in lines 3 and 4.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the headline results are empirical measurements, Trueput is an evaluation definition rather than a fitted input, and the self-citations point to reproducible methods and benchmarks.

full rationale

The paper's central claims are empirical measurements on HLS and Qiskit benchmarks, not derivations from a fitted or self-referential model. Trueput (Eq. 1) is introduced as a definition, Pass@k over inference latency, and Eq. 2 substitutes the standard Codex Pass@k estimate; the existence of a finite optimal sample count is hypothesized and then verified empirically in Fig. 6, rather than used to fit any result. The reported 2.3x speedup in Sec. VI-D is obtained from a fixed tree-size sweep (peak at 60), with the optimal configuration determined offline, so it supports preconfigured parallel decoding rather than the online KL-based acceleration learning in Sec. V-B. That online objective is not evaluated in the experiments, but this is a completeness or correctness risk, not a circular step. Self-citations to prior work on parallel decoding [6], the HLS benchmark [12], and the Qiskit multi-agent baseline [4] are reproducible external artifacts; they do not embed the present paper's fitted values or final predictions. No equation or claimed result reduces by construction to its own input, and no prediction is statistically forced by a fitted parameter. The paper is therefore self-contained with respect to circularity concerns.

Assumptions & free parameters 3 free parameters · 4 assumptions · 1 invented entities

The framework relies on two domain choices (syntax-accuracy weighting and Dirichlet client simulation), one unproved mechanism (online learning of acceleration parameters), and one standard estimation assumption (independent Pass@k). The tuned tree size and sample count are fit to validation hardware. No new physical entity is introduced, but the online-learned acceleration parameters are a proposed construct without external verification.

free parameters (3)
  • Parallel decoding tree size = around 60 for measured speedup peak
    Chosen per client or compute budget in Sec. VI-D; the speedup curve peaks at a finite tree size, so the value is fit to the deployment hardware.
  • Number of samples k per request = varies with GPU capacity, roughly 6 under full capacity in Fig. 6
    Optimized to maximize Trueput in Sec. VI-E; it is a tuned hyperparameter rather than a derived constant.
  • Sampling hyperparameters = not fixed; grid-searched per client including temperature, top-k, top-p, and beam width
    Table I lists configurations; Sec. VI-D selects strategies per client via a one-time offline search, so the values are fitted to validation performance.
assumptions (4)
  • domain assumption Syntax accuracy computed on a validation set is a sufficient proxy for hardware design quality and a reliable aggregation weight in federated learning and model merging.
    Used throughout Sec. VI-A to weight client models; if syntax accuracy does not correlate with semantic correctness or deployment quality, metric-based aggregation has no basis.
  • domain assumption A Dirichlet partition of the HLS and Qiskit datasets by repository ID reproduces the client data heterogeneity of real decentralized hardware design settings.
    Sec. VI-A states this split is used to simulate real-world heterogeneity; the validity of the entire FL evaluation depends on this simulation matching practice.
  • ad hoc to paper The acceleration parameters phi can be learned online from user-generated deployment outputs by minimizing the KL divergence between the accelerated and target model distributions.
    Sec. V-B introduces this as the foundation of personalized inference-time acceleration; the paper provides no proof, convergence analysis, or experiment for this assumption.
  • domain assumption Pass@k is estimated by the Codex formula 1 - (1-p)^k with a per-sample pass probability p.
    Used in Eq. (2) for Trueput; this standard estimate assumes independent samples, which is only an approximation for correlated LLM samples.
invented entities (1)
  • Online-learned acceleration parameter vector phi
    purpose: Learned from live deployment outputs to approximate the target model's predictive distribution and enable multi-token parallel decoding.
    Proposed in Sec. V-B; no experiment or public artifact verifies that the learned parameters reproduce the target distribution, so the entity has no falsifiable handle outside the paper.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Advancing AI-assisted Hardware Design with Hierarchical Decentralized Training and Personalized Inference-Time Optimization." pith.science (2026). https://pith.science/paper/RJRSI4KM

@misc{pith2026250600002,
  author       = {Pith},
  title        = {Pith review of: Advancing AI-assisted Hardware Design with Hierarchical Decentralized Training and Personalized Inference-Time Optimization},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/RJRSI4KM}},
  note         = {Machine review of arXiv:2506.00002}
}
abstract

Recent years have witnessed a significant increase in the adoption of AI techniques to enhance electronic design automation. In particular, the emergence of Large Language Models (LLMs) has sparked significant interest in LLM-assisted hardware design generation, spanning applications from classical digital circuits to quantum computing. Despite substantial progress in this direction, the quality of LLM-generated hardware design still cannot meet the requirements for practical deployment. In this work, we identify three critical challenges hindering the development of LLM-assisted hardware design generation: 1) limited data availability, 2) varied data quality, 3) inadequate inference-time efficiency. To address these fundamental challenges, this paper introduces a two-stage framework for AI-assisted hardware design by exploring decentralized training and personalized inference. In the first stage, we propose to harness private domain design sources through a hierarchical decentralized training mechanism that addresses data-sharing constraints. To mitigate the impact of low-quality data, we identify optimization opportunities in hardware generation tasks, using user-defined metrics for model aggregation. The second stage focuses on client personalization to enhance both speed and quality. We introduce a new metric, Trueput, to analyze LLM-assisted hardware generation efficiency. To optimize Trueput, we implement personalized inference-time acceleration and customized sampling strategies. Evaluating both classical and quantum benchmarks, our experimental results demonstrate that the proposed two-stage framework can significantly improve the model capability for hardware design generation. As orthogonal enhancements to existing methods, our framework can achieve $33\% \sim 50\%$ semantic accuracy improvement and $2.3$ times speedup, depending on the difficulty of the generation tasks.

Figures

Figures reproduced from arXiv: 2506.00002 by the authors.

Figure 1
Figure 1. An overview of our proposed two-stage framework for [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗
Figure 2
Figure 2. The vision and overview of our proposed framework [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗
Figure 4
Figure 4. Evaluation of federated learning on both classical and [PITH_FULL_IMAGE:figures/full_fig_p005_4.png] view at source ↗
Figures from the paper (3 more)
Figure 3
Figure 3. Figure 3: Effect of hierarchical approach on both classical and [PITH_FULL_IMAGE:figures/full_fig_p005_3.png]
Figure 5
Figure 5. Figure 5: Personalized Test-Time Optimization. Left: multi￾token generation. Right: Customized sampling for HLS mod￾els. Combined Sampling uses both top-k and top-p filtering. 1 2 3 4 5 6 7 8 9 10 Sample Number 35 40 45 50 55 60 pass@k (%) Pass@k Sampling Latency (full GPU Capac…
Figure 6
Figure 6. Figure 6: Trueput Evaluation. Left: Pass@k and latency for different sample sizes. Right: Trueput across GPU capacities. for personalized inference-time optimizations to advance AI￾assisted hardware design. The optimal configuration for each client can be determined offline with…

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

50 extracted references · 27 canonical work pages

  1. [4]

    Enhancing llm-based quantum code generation with multi- agent optimization and quantum error correction

    Charlie Campbell, Hao Mark Chen, Wayne Luk, and Hongxiang Fan. Enhancing llm-based quantum code generation with multi- agent optimization and quantum error correction. arXiv preprint arXiv:2504.6375344, 2025

    work page arXiv 2025

  2. [1]

    Hierarchical federated learning across heterogeneous cellular networks

    Mehdi Salehi Heydar Abad et al. Hierarchical federated learning across heterogeneous cellular networks. In ICASSP 2020-2020 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 8866–8870. IEEE, 2020

    work page 2020

  3. [2]

    A survey on data selection for language models

    Alon Albalak et al. A survey on data selection for language models. arXiv preprint arXiv:2402.16827 , 2024

    arXiv 2024

  4. [3]

    Medusa: Simple LLM Inference Acceleration Frame- work with Multiple Decoding Heads

    Tianle Cai et al. Medusa: Simple LLM Inference Acceleration Frame- work with Multiple Decoding Heads. arXiv preprint arXiv:2401.10774, 2024

    arXiv 2024

  5. [5]

    Chipgpt: How far are we from natural language hardware design

    Kaiyan Chang et al. Chipgpt: How far are we from natural language hardware design. arXiv preprint arXiv:2305.14019 , 2023

    arXiv 2023

  6. [6]

    Hardware-aware parallel prompt decoding for memory-efficient acceleration of llm inference

    Hao Mark Chen et al. Hardware-aware parallel prompt decoding for memory-efficient acceleration of llm inference. arXiv preprint arXiv:2405.18628, 2024

    arXiv 2024

  7. [7]

    Fw-merging: Scaling model merging with frank-wolfe optimization

    Hao Mark Chen, Shell Xu Hu, Wayne Luk, Timothy Hospedales, and Hongxiang Fan. Fw-merging: Scaling model merging with frank-wolfe optimization. arXiv preprint arXiv:2503.12649 , 2025

    work page arXiv 2025

  8. [8]

    Evaluating large language models trained on code

    Mark Chen et al. Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 , 2021

    arXiv 2021

Show all 50 references
  1. [9]

    Qiskit code assistant: Training llms for generating quantum computing code

    Nicolas Dupuis et al. Qiskit code assistant: Training llms for generating quantum computing code. arXiv preprint arXiv:2405.19495 , 2024

    2024 arXiv

  2. [10]

    What’s in my big data? In The Twelfth International Conference on Learning Representations , 2024

    Yanai Elazar et al. What’s in my big data? In The Twelfth International Conference on Learning Representations , 2024

    2024

  3. [11]

    Llm4sechw: Leveraging domain-specific large language model for hardware debugging

    Weimin Fu et al. Llm4sechw: Leveraging domain-specific large language model for hardware debugging. In 2023 Asian Hardware Oriented Security and Trust Symposium (AsianHOST) , pages 1–6. IEEE, 2023

    2023

  4. [12]

    Exploring code language models for automated hls-based hardware generation: Benchmark, infrastructure and analysis

    Jiahao Gai, Hao Chen, Zhican Wang, Hongyu Zhou, Wanru Zhao, Nicholas Lane, and Hongxiang Fan. Exploring code language models for automated hls-based hardware generation: Benchmark, infrastructure and analysis. In Proceedings of the 30th Asia and South Pacific Design Automation...

    2025

  5. [13]

    Federated learning as a service for hierarchical edge networks with heterogeneous models

    Wentao Gao et al. Federated learning as a service for hierarchical edge networks with heterogeneous models. arXiv preprint arXiv:2407.20573, 2024

    2024 arXiv

  6. [14]

    Flight: A faas-based framework for complex and hierarchical federated learning

    Nathaniel Hudson et al. Flight: A faas-based framework for complex and hierarchical federated learning. arXiv preprint arXiv:2409.16495 , 2024

    2024 arXiv

  7. [15]

    Editing models with task arithmetic

    Gabriel Ilharco et al. Editing models with task arithmetic. arXiv preprint arXiv:2212.04089, 2022

    2022 arXiv

  8. [16]

    A survey on large language models for code generation

    Juyong Jiang et al. A survey on large language models for code generation. arXiv preprint arXiv:2406.00515 , 2024

    2024 arXiv

  9. [17]

    From llms to llm-based agents for software engi- neering: A survey of current, challenges and future

    Haolin Jin et al. From llms to llm-based agents for software engi- neering: A survey of current, challenges and future. arXiv preprint arXiv:2408.02479, 2024

    2024 arXiv

  10. [18]

    Advances and open problems in federated learning

    Peter Kairouz et al. Advances and open problems in federated learning. Foundations and trends® in machine learning , 14(1–2):1–210, 2021

    2021

  11. [19]

    Survey of personalization techniques for federated learning

    Viraj Kulkarni et al. Survey of personalization techniques for federated learning. In 2020 fourth world conference on smart trends in systems, security and sustainability (WorldS4) , pages 794–797. IEEE, 2020

    2020

  12. [20]

    Datainf: Efficiently estimating data influence in loRA-tuned LLMs and diffusion models

    Yongchan Kwon et al. Datainf: Efficiently estimating data influence in loRA-tuned LLMs and diffusion models. In The Twelfth International Conference on Learning Representations , 2024

    2024

  13. [21]

    Fedl2p: Federated learning to personalize

    Royson Lee et al. Fedl2p: Federated learning to personalize. Advances in Neural Information Processing Systems , 36, 2024

    2024

  14. [22]

    Federated learning on non-iid data silos: An exper- imental study

    Qinbin Li et al. Federated learning on non-iid data silos: An exper- imental study. In 2022 IEEE 38th international conference on data engineering (ICDE), pages 965–978. IEEE, 2022

    2022

  15. [23]

    EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty

    Yuhui Li et al. EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty. arXiv preprint arXiv:2401.15077 , 2024

    2024 arXiv

  16. [24]

    Think locally, act globally: Federated learning with local and global representations

    Paul Pu Liang et al. Think locally, act globally: Federated learning with local and global representations. arXiv preprint arXiv:2001.01523, 2020

    2001 arXiv

  17. [25]

    Are llms any good for high-level synthesis? arXiv preprint arXiv:2408.10428, 2024

    Yuchao Liao et al. Are llms any good for high-level synthesis? arXiv preprint arXiv:2408.10428, 2024

    2024 arXiv

  18. [26]

    Let’s verify step by step

    Hunter Lightman et al. Let’s verify step by step. arXiv preprint arXiv:2305.20050, 2023

    2023 arXiv

  19. [27]

    Verilogeval: Evaluating large language models for verilog code generation

    Mingjie Liu et al. Verilogeval: Evaluating large language models for verilog code generation. In 2023 IEEE/ACM International Conference on Computer Aided Design (ICCAD) , pages 1–8. IEEE, 2023

    2023

  20. [28]

    Rtlcoder: Outperforming gpt-3.5 in design rtl generation with our open-source dataset and lightweight solution

    Shang Liu et al. Rtlcoder: Outperforming gpt-3.5 in design rtl generation with our open-source dataset and lightweight solution. In 2024 IEEE LLM Aided Design Workshop (LAD) , pages 1–5. IEEE, 2024

    2024

  21. [29]

    Starcoder 2 and the stack v2: The next generation, 2024

    Anton Lozhkov et al. Starcoder 2 and the stack v2: The next generation, 2024

    2024

  22. [30]

    Rtllm: An open-source benchmark for design rtl generation with large language model

    Yao Lu et al. Rtllm: An open-source benchmark for design rtl generation with large language model. In 2024 29th Asia and South Pacific Design Automation Conference (ASP-DAC), pages 722–727. IEEE, 2024

    2024

  23. [31]

    Communication-efficient learning of deep networks from decentralized data

    Brendan McMahan et al. Communication-efficient learning of deep networks from decentralized data. In Artificial intelligence and statistics, pages 1273–1282. PMLR, 2017

    2017

  24. [32]

    SpecInfer: Accelerating Large Language Model Serving with Tree-based Speculative Inference and Verification

    Xupeng Miao et al. SpecInfer: Accelerating Large Language Model Serving with Tree-based Speculative Inference and Verification. In ACM International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS) , 2024

    2024

  25. [33]

    Soft merging of experts with adaptive routing

    Mohammed Muqeeth et al. Soft merging of experts with adaptive routing. arXiv preprint arXiv:2306.03745 , 2023

    2023 arXiv

  26. [34]

    Federated learning for internet of things: A comprehensive survey

    Dinh C Nguyen et al. Federated learning for internet of things: A comprehensive survey. IEEE Communications Surveys & Tutorials , 23(3):1622–1658, 2021

    2021

  27. [35]

    Model aggregation techniques in federated learning: A comprehensive survey

    Pian Qi et al. Model aggregation techniques in federated learning: A comprehensive survey. Future Generation Computer Systems , 150:272– 293, 2024

    2024

  28. [36]

    Recursive introspection: Teaching language model agents how to self-improve

    Yuxiao Qu et al. Recursive introspection: Teaching language model agents how to self-improve. arXiv preprint arXiv:2407.18219 , 2024

    2024 arXiv

  29. [37]

    Code llama: Open foundation models for code

    Baptiste Roziere et al. Code llama: Open foundation models for code. arXiv preprint arXiv:2308.12950 , 2023

    2023 arXiv

  30. [38]

    Privacy-preserving deep learning

    Reza Shokri et al. Privacy-preserving deep learning. In Proceedings of the 22nd ACM SIGSAC conference on computer and communications security, pages 1310–1321, 2015

    2015

  31. [39]

    Scaling llm test-time compute optimally can be more effective than scaling model parameters

    Charlie Snell et al. Scaling llm test-time compute optimally can be more effective than scaling model parameters. arXiv preprint arXiv:2408.03314, 2024

    2024 arXiv

  32. [40]

    Personalized federated learning with moreau en- velopes

    Canh T Dinh et al. Personalized federated learning with moreau en- velopes. Advances in neural information processing systems , 33:21394– 21405, 2020

    2020

  33. [41]

    Verigen: A large language model for verilog code generation

    Shailja Thakur et al. Verigen: A large language model for verilog code generation. ACM Transactions on Design Automation of Electronic Systems, 29(3):1–31, 2024

    2024

  34. [42]

    Rtlfixer: Automatically fixing rtl syntax errors with large language models

    Yun-Da Tsai et al. Rtlfixer: Automatically fixing rtl syntax errors with large language models. arXiv preprint arXiv:2311.16543 , 2023

    2023 arXiv

  35. [43]

    Huggingface’s transformers: State-of-the-art natural language processing

    T Wolf. Huggingface’s transformers: State-of-the-art natural language processing. arXiv preprint arXiv:1910.03771 , 2019

    1910 arXiv

  36. [44]

    Hlspilot: Llm-based high-level synthesis

    Chenwei Xiong et al. Hlspilot: Llm-based high-level synthesis. arXiv preprint arXiv:2408.06810, 2024

    2024 arXiv

  37. [45]

    Optimizing high-level synthesis designs with retrieval-augmented large language models

    Haocheng Xu et al. Optimizing high-level synthesis designs with retrieval-augmented large language models. In 2024 IEEE LLM Aided Design Workshop (LAD), pages 1–5. IEEE, 2024

    2024

  38. [46]

    Assertllm: Generating and evaluating hardware verification assertions from design specifications via multi-llms

    Zhiyuan Yan et al. Assertllm: Generating and evaluating hardware verification assertions from design specifications via multi-llms. arXiv preprint arXiv:2402.00386, 2024

    2024

  39. [47]

    Model merging in llms, mllms, and beyond: Methods, theories, applications and opportunities

    Enneng Yang et al. Model merging in llms, mllms, and beyond: Methods, theories, applications and opportunities. arXiv preprint arXiv:2408.07666, 2024

    2024 arXiv

  40. [48]

    Heterogeneous federated learning: State-of-the-art and research challenges

    Mang Ye et al. Heterogeneous federated learning: State-of-the-art and research challenges. ACM Computing Surveys , 56(3):1–44, 2023

    2023

  41. [49]

    Language models are super mario: Absorbing abilities from homologous models as a free lunch

    Le Yu et al. Language models are super mario: Absorbing abilities from homologous models as a free lunch. In Forty-first International Conference on Machine Learning , 2024

    2024

  42. [50]

    Knowledge composition using task vectors with learned anisotropic scaling

    Frederic Z Zhang et al. Knowledge composition using task vectors with learned anisotropic scaling. arXiv preprint arXiv:2407.02880 , 2024

    2024 arXiv

Pith tools

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