Paper deep dive
Unlocking Parallelism in Autoregressive Language Models via Speculative Decoding with Progressive Tree Drafting
Zipeng Gao, Zhi Zheng, Qingrong Xia, Junda Lin, Ziwei Zhao, Tong Xu, Zhefeng Wang, Enhong Chen
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 90%
Last extracted: 7/18/2026, 12:15:31 PM
Summary
The paper introduces Progressive Tree Drafting (PTD), a training-free, model-agnostic method for accelerating Large Language Model (LLM) inference. PTD utilizes a structured, guided parallel drafting strategy that employs a progressive tree structure and stepwise pruning to explore multiple semantic paths in a single forward pass. This approach eliminates computational redundancy found in linear drafting methods, achieving up to a 2x decoding speedup across various benchmarks without requiring auxiliary draft modules.
Entities (11)
Relation Signals (7)
Progressive Tree Drafting → achievesspeedup → 2x
confidence 95% · Experiments demonstrate that PTD achieves up to 2x decoding speedup across various benchmarks
Progressive Tree Drafting → istrainingfree → true
confidence 95% · Experiments demonstrate that PTD achieves up to 2x decoding speedup ... while remaining training-free and model-agnostic.
Progressive Tree Drafting → usesmechanism → Progressive Tree Structure
confidence 92% · By coupling a progressive tree structure with a stepwise pruning mechanism, PTD actively guides the LLM
Speculative Decoding → alleviates → Memory-bound bottlenecks
confidence 90% · Speculative decoding has significantly accelerated Large Language Model (LLM) inference by alleviating memory-bound bottlenecks.
Traditional Speculative Decoding → relieson → Auxiliary draft modules
confidence 88% · However, traditional speculative decoding typically relies on auxiliary draft modules, incurring significant training and communication overhead.
Progressive Tree Drafting → outperforms → Lookahead Decoding
confidence 85% · PTD consistently achieves the highest speedup across all evaluated models and tasks, outperforming state-of-the-art training-free baselines like LADE and Self-Draft.
Progressive Tree Drafting → outperforms → Self-Draft
confidence 85% · PTD consistently achieves the highest speedup across all evaluated models and tasks, outperforming state-of-the-art training-free baselines like LADE and Self-Draft.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Speculative decoding has significantly accelerated Large Language Model (LLM) inference by alleviating memory-bound bottlenecks. However, traditional speculative decoding typically relies on auxiliary draft modules, incurring significant training and communication overhead. Although recent methods attempt to generate drafts within the target model itself, they often fail to fully exploit its latent parallel capacity due to a lack of structural coordination. In this paper, we propose \textbf{Progressive Tree Drafting (PTD)}, which employs a structured, guided parallel drafting strategy to harness the model's parallel potential. By coupling a progressive tree structure with a stepwise pruning mechanism, PTD actively guides the LLM to explore multiple semantic paths in a single forward pass, ensuring both draft diversity and coherence. Experiments demonstrate that PTD achieves up to $2\times$ decoding speedup across various benchmarks while remaining training-free and model-agnostic. Our code is available at: this https URL.
Tags
Links
- Source: https://arxiv.org/abs/2607.10661v1
- Canonical: https://arxiv.org/abs/2607.10661v1
Trouble viewing inline? Open PDF directly →
Full Text
46,237 characters extracted from source content.
Expand or collapse full text
Unlocking Parallelism in Autoregressive Language Models via Speculative Decoding with Progressive Tree Drafting Zipeng Gao1 Zhi Zheng1 Qingrong Xia2 Junda Lin1 Ziwei Zhao1 Tong Xu1 Zhefeng Wang2 Enhong Chen1 1State Key Laboratory of Cognitive Intelligence, University of Science and Technology of China 2Huawei Technologies Co., Ltd. gaozp619,zhengzhi97,linjunda,zzw22222@mail.ustc.edu.cn zhengzhi97,tongxu,cheneh@ustc.edu.cn xiaqingrong,wangzhefeng@huawei.com Corresponding author Abstract Speculative decoding has significantly accelerated Large Language Model (LLM) inference by alleviating memory-bound bottlenecks. However, traditional speculative decoding typically relies on auxiliary draft modules, incurring significant training and communication overhead. Although recent methods attempt to generate drafts within the target model itself, they often fail to fully exploit its latent parallel capacity due to a lack of structural coordination. In this paper, we propose Progressive Tree Drafting (PTD), which employs a structured, guided parallel drafting strategy to harness the model’s parallel potential. By coupling a progressive tree structure with a stepwise pruning mechanism, PTD actively guides the LLM to explore multiple semantic paths in a single forward pass, ensuring both draft diversity and coherence. Experiments demonstrate that PTD achieves up to 2×2× decoding speedup across various benchmarks while remaining training-free and model-agnostic. Our code is available at: https://github.com/MINE-USTC/PTD. 1 Introduction Speculative decoding has emerged as an important paradigm for accelerating Large Language Model (LLM) inference, mitigating the memory-bound bottlenecks inherent in autoregressive generation (Yuan et al., 2024; Xia et al., 2024). By transforming the inefficient token-by-token processing into a candidate parallel verification process, this paradigm enhances computational utility and inference speed without compromising generation quality. The key to speculative decoding is obtaining high-quality drafts. Traditional approaches typically employ smaller auxiliary modules to generate drafts, which often incur significant communication overhead and require substantial training effort for model alignment (Xia et al., 2023; Leviathan et al., 2023; Chen et al., 2023; Miao et al., 2024; Yang et al., 2024; Cai et al., 2024; Stern et al., 2018; Li et al., 2025). To mitigate these issues, recent research has shifted toward training-free, model-agnostic strategies that generate drafts directly within the target LLM itself. For instance, Lookahead Decoding (LADE) (Fu et al., 2024) supplements the primary decoding objective with a parallel Jacobi iteration task to predict and refine linear candidate sequences, while Self-Draft (Gao et al., 2025) leverages the intrinsic robustness of LLMs to incorporate an auxiliary drafting task, generating multiple candidate branches through input perturbations. While these methods confirm the feasibility of endogenous acceleration, we argue that the latent parallel processing capabilities inherent in AR models remain under-exploited, primarily due to the independent and unstructured nature of their candidate generation. Specifically, our in-depth analysis reveals a critical bottleneck in this paradigm. As quantified in Figure 2 (right), our analysis of Self-Draft shows that more than half of the decoding steps contain branches with over 80% similarity. This high level of semantic redundancy suggests that simply generating independent linear branches fails to effectively direct the model’s parallel resources toward diverse drafting. This observation motivates us to rethink: how can we more intentionally and structurally guide the model to transform its parallel potential into high-quality, diverse drafts? Figure 1: Paradigms of speculative decoding. (Left) Traditional methods using auxiliary draft modules. (Right) Endogenous, training-free methods. Figure 2: A drafting example (left) and the branch similarity analysis (right) of Self-Draft (Gao et al., 2025). The curve means the proportion of steps with at least two branches above the similarity threshold. Building on this insight, we propose Progressive Tree Drafting (PTD), a novel strategy that reformulates drafting as a structured, guided parallel inference process. By leveraging a tree structure to merge redundant prefixes, PTD eliminates the computational waste inherent in independent branching. Furthermore, the integration of a progressively updated evolution with a stepwise pruning mechanism allows PTD to guide the LLM to explore multiple distinct semantic paths within a single forward pass. This approach ensures the generated drafts are both diverse and coherent, thereby increasing the acceptance rate and unlocking the model’s parallel potential. The main contributions of this paper are summarized as follows: • We identify and quantify the computational redundancy in existing linear or unstructured drafting methods, revealing that they fail to fully exploit the parallel capacity of AR models. • We introduce Progressive Tree Drafting (PTD), a strategy that reformulates drafting into a structured, guided parallel generation process to ensure both draft diversity and coherence. • Experimental results demonstrate that PTD consistently achieves up to a 2×2× speedup across various benchmarks without requiring any auxiliary modules. The structure of this paper is as follows: First, we review related works, followed by a detailed description of the proposed method. Then, we present experimental results to validate its effectiveness. Finally, we conclude the paper and discuss potential directions for future research. 2 Related Works 2.1 Speculative Decoding with Additional Modules The conventional speculative decoding paradigm relies on additional modules, including independent models and architectural extensions, to generate candidate tokens. The initial formulation (Xia et al., 2023; Leviathan et al., 2023) employs a smaller, independent draft model to generate candidates, which are then verified by the target LLM. These methods suffer from serialization bottlenecks and heavy reliance on the draft model’s accuracy. PEARL (Liu et al., 2025) and SwiftSpec (Zhang et al., 2025) addresses these synchronization issues by optimizing the interaction protocol between the drafting and verification stages. Subsequent works like MCSD (Yang et al., 2024) and SpecInfer (Miao et al., 2024) extend this by using multiple draft models or sampling strategies to boost diversity, yet the maintenance of separate models remains a bottleneck. JudgeDecoding (Bachmann et al., 2025) adopts a relaxed alignment paradigm to boost verification speed via a marginal accuracy loss. Retrieval-based methods such as REST (He et al., 2023) substitute the draft model with an external datastore module, but this shifts the dependency to the quality and domain relevance of the retrieved corpus. Alternatively, some approaches integrate the drafting module directly into the target model’s architecture. The EAGLE series (Li et al., 2024a; b), Medusa (Cai et al., 2024), Blockwise Decoding (Stern et al., 2018), Hydra (Ankner et al., 2024) attach additional prediction heads or layers to the LLM to predict future tokens in parallel. Although these architectural modifications reduce communication latency compared to independent models, they fundamentally alter the model structure, requiring substantial extra training and preventing seamless deployment on off-the-shelf LLMs. 2.2 Training-Free Endogenous Acceleration In contrast to module-based approaches, a recent line of research focuses on endogenous acceleration, which exploits the target LLM’s latent capabilities to generate drafts without any additional modules or training. Lookahead Decoding (LADE) (Fu et al., 2024) utilizes the Jacobi iteration method to perform parallel decoding within the original model architecture. Parallelly, Self-Draft (Gao et al., 2025) leverages the intrinsic robustness of LLMs, employing multi-branch input perturbations to induce the model to generate its own drafts. These methods represent a shift towards architecture-agnostic acceleration. However, as discussed in the Introduction, current endogenous methods often rely on linear or iterative generation schemes that lack structural coordination, failing to fully harness the model’s parallel potential. Our Progressive Tree Drafting (PTD) advances this paradigm by introducing a structured, guided exploration mechanism, achieving efficient self-acceleration without the burden of extra modules. 3 Methodology Conventional autoregressive decoding predicts one token at a time. Given a prefix =[x1,x2,⋯,xt−1]X=[x_1,x_2,·s,x_t-1], the LLM computes the next-token distribution P(yt|)P(y_t|X) and selects the next token with a decoding strategy S: xt=(P(yt|))x_t=S(P(y_t|X)) Speculative decoding generalizes this step by introducing candidate continuations C_X and verifying them in parallel: xt,xt+1,…,xt+k=(P(yt,|[;])),x_t,x_t+1,...,x_t+k=S (P(y_t,y_C|[X;C_X]) ), These formulations provide the theoretical foundation for speculative decoding. In practice, traditional implementations typically rely on external draft models, yet this dependency incurs alignment and communication overhead. Endogenous acceleration offers a more efficient alternative by leveraging the target model’s internal parallel processing capacity. Specifically, the inference behavior of Transformer-based LLMs is governed by the input content and the attention matrix. By reconfiguring the input content and the attention mask, we can transfer the model’s attention from a linear path and to a multiple, concurrent reasoning trajectories. This flexibility allows the LLM to explore a structured semantic space and generate high-quality drafts in a single forward pass. Based on this insight, we develop Progressive Tree Drafting (PTD) to transform the model’s parallel potential into actual decoding speedup. The design of PTD focuses on solving two practical issues: how to organize the parallel drafting paths and how to maintain their contextual coherence. For the former, we adopt a drafting tree, as its prefix-sharing nature represents the most complex topology theoretically supported by autoregressive models. For the latter, we introduce a progressive update algorithm with stepwise pruning to ensure the generated content remains context-relevant. Figure 3: Overview of the Progressive Tree Drafting (PTD) framework. The green pathway illustrates the verification process of candidate drafts, while the blue pathway denotes the semantic-guided progressive tree drafting process. The red box indicates the decoded results. Figure 3 illustrates the overall framework of PTD. In the following subsections, we begin by introducing the tree expansion and pruning strategies that regulate the dynamic evolution of the drafting tree. Then, we detail the draft extraction process and the verification mechanism. 3.1 Progressive Tree Drafting To transform the parallel potential of LLMs into actual speedup, we propose the Progressive Tree Drafting (PTD) mechanism. This section details the tree’s lifecycle, from its structural initialization to its dynamic evolution and pruning. Tree Construction. We represent the drafting structure as a tree T=(V,E)T=(V,E). To bootstrap the progressive process, T is first initialized with a set of seed nodes. These nodes can be generated stochastically or derived from semantic information in the context, serving to trigger the LLM’s reasoning across diverse semantic trajectories. To ensure semantic consistency, each node v∈Vv∈ V must only attend to its ancestors. Formally, for any node v, the set of its observable prefix nodes π(v)π(v) is defined recursively: π(v)=v∪π((v))π(v)=\v\∪π(P(v)) where (v)P(v) denotes the unique parent of node v. The positional encoding for node v is determined by the cardinality of π(v)π(v), ensuring that the tree-structured input remains compatible with the Transformer’s causal attention. Progressive Expansion. The inference on the draft tree Tt−1T^t-1 at step t is formulated as: xt,t=(P(yt,T|[;Tt−1]))x_t,D_t=S (P (y_t,y_T|[X;T^t-1] ) ) where t=dv∣v∈Vt−1D_t=\d_v v∈ V^t-1\ is the set of draft tokens generated by all nodes in Tt−1T^t-1 in a single forward pass. PTD then evolves the draft tree to Tt=(Vt,Et)T^t=(V^t,E^t) by appending these newly generated tokens as child nodes: Vt=Vt−1∪dvv∈Vt−1,Et=Et−1∪(v,dv)v∈Vt−1V^t=V^t-1∪\d_v\_v∈ V^t-1, E^t=E^t-1∪\(v,d_v)\_v∈ V^t-1 Figure 4: Illustration stepwise prune algorithms. Overhead Constraints. Generally, the number of nodes in the draft tree ensures the diversity of the drafts it generates, and the expansion process maintains the semantic coherence between the adjacent nodes in the tree. However, the computational overhead introduced by the draft tree increases progressively as it grows. Hence, it is necessary to impose constraints on its growth to prevent excessive size, which could otherwise degrade the overall decoding speed. Specifically, we impose constraints on the tree’s topology along two dimensions: • Width Control: We limit the max number of child nodes for each parent. This prevents low-confidence tokens from branching excessively, ensuring that the tree focuses on high-probability reasoning paths. • Stepping Mechanism (Depth Control): To prevent the tree from becoming overly deep, we implement a sliding-window-style stepping mechanism. As illustrated in Figure 4, when a sub-tree exceeds a depth threshold, we retain the earliest-added child and its descendants as the new sub-tree, pruning all other stale branches. This stepping-wise prune mechanism helps preserve the semantic coherence and contextual relevance of the draft tree. These parameters allow for fine-grained control over the draft tree’s complexity to suit different model scales and application requirements. In the following experimental section, we provide a thorough evaluation of how these constraints influence the trade-off between drafting efficiency and overall speedup. Draft Extraction via Merging. Finally, we extract semantic subtrees from the expanded draft tree TtT^t and aggregate them with the existing candidates in the draft cache pool. Specifically, any subtree T′T in the draft tree TtT^t will be merged with the cached candidate tree that shares the same root node value. We define the following recursive merging function ℳM for any two trees T and T′T with same root r: ℳ(T,T′)=(V∪v,E∪(r,v)),∀v∈σ(T′)∖σ(T)ℳ(Tv,Tv′),∀v∈σ(T′)∩σ(T),M(T,T )= cases (V∪ v,E∪(r,v) ),∀ v∈σ(T ) σ(T)\\ M(T_v,T _v),∀ v∈σ(T )∩σ(T) cases, where σ(T)σ(T) denotes the set of direct child nodes of the tree T, and TvT_v is the subtree with root of v in tree T. 3.2 Candidate Verification In parallel with the autoregressive decoding process and the progressive tree drafting process, a candidate tree validation process is concurrently executed during the forward pass. Given the partially decoded token sequence X, we retrieve corresponding drafts from the draft pool, forming the candidate tree C_X. To verify this candidate tree, we apply the similar attention mask and positional encoding strategy as used in the drafting process. Consequently, after a forward pass through the LLM, each node in C_X produces a verification token conditioned on its prefix. Together with the autoregressive decoding process and the progressive tree drafting process, we formulate the overall model forward process as follows: xt,,=(P(yt,T,|[;Ti−1;])),x_t,D,V=S (P(y_t,y_T,y_C|[X;T^i-1;C_X]) ), where V denotes the verification tokens that are generated by each node and its prefix in the candidate tree. Finally, the accepted tokens ′X can be obtained by identifying all eligible edges ℐI in the candidate tree. Under the greedy decoding strategy, the verification tokens V for all nodes V_C_X of the candidate tree C_X are selected based on the model’s highest-probability predictions. Eligible edges are identified recursively by verifying whether a node’s verification token appears among its child nodes. That is: ℐ=(n,n)|n∈σ(n),∀n∈V.I=\(n,V_n)|V_n∈σ(n),∀ n∈ V_C_X\. For the sampling decoding strategy, we determine whether each token is accepted using a without-replacement sampling method based on normalized probabilities, following an approach similar to LADE (Fu et al., 2024) and SpecInfer (Miao et al., 2024). Specifically, starting from the root node of the candidate draft tree, the LLM produces a probability distribution PvP_v over the next token at each node v. Each node may have multiple successor nodes [c1,c2,…,ck][c_1,c_2,...,c_k], and a sampling process is iteratively applied to these k candidates. At each iteration, a random number r∼(0,1)r (0,1) is drawn, and the candidates are traversed in order. If r≤Pir≤ P_i, the candidate cic_i is selected, and the edge between cic_i and its parent node is marked as eligible and appended to the eligible edge set ℐI. If not, PiP_i is set to zero, and the remaining probabilities are renormalized. This process continues until a candidate satisfies r≤Pir≤ P_i, ensuring that the final selection remains faithful to the original distribution. We provide the full PTD decoding algorithm, the recursive candidate-tree sampling algorithm, and the proof of distributional consistency in Appendices D, E, and F. The final accepted sequence is the path formed by eligible edges starting from the root node n0n_0. That is, ′=(n0,n1,…nk,nk)X =(n_0,n_1,...n_k,V_n_k) where ∀i<k,(ni,ni+1)∈ℐ∀ i<k,(n_i,n_i+1) and ′X are the tokens we decoded in a single model forward pass. 4 Experiments 4.1 Settings Benchmarks. To evaluate the performance of PTD across diverse scenarios, we utilize several representative benchmarks. For general conversation, we use MT-Bench (Zheng et al., 2023), which covers eight distinct task categories with 80 problems in total. For mathematical reasoning, we randomly sample 100 questions from the GSM-8k (Cobbe et al., 2021) dataset. For code generation, we employ the full HumanEval (Chen et al., 2021) dataset and a 100-problem test subset from MBPP (Austin et al., 2021). Baselines. We compare PTD against several representative strategies. Standard Autoregressive (AR) decoding serves as the primary baseline, and the training-free baselines include Lookahead Decoding (LADE) (Fu et al., 2024) and Self-Draft (Gao et al., 2025). All baseline hyperparameters are kept at their default settings. Models. For general conversation (MT-Bench) and mathematical reasoning (GSM-100), we employ LLaMA-2 (7B/13B), LLaMA-3 (8B), Qwen-2.5 (7B/14B/32B), and Qwen-3 (8B/14B). For code generation (HumanEval, MBPP-100), we utilize CodeLLaMA-7B/13B. Metrics. We employ five metrics for evaluation: (i) Throughput (TP) (tokens/s) for end-to-end speed; (i) Accept Length (AL) and (i) Hit Rate (HR) to characterize draft coherence and diversity; (iv) Decoding Efficiency (DE), the average tokens produced per forward pass, defined as: DE=HR⋅AL+(1−HR)DE=HR·AL+(1-HR) and (v) Computational Overhead, the average additional tokens processed per step during drafting (DftDft) and verification (VerVer). All experiments were conducted on NVIDIA L20 GPUs (48 GB RAM) using BF16 precision to enhance computational efficiency. Inference was performed consistently with a batch size of one throughout. Unless otherwise specified, all draft tokens are obtained via greedy (Top-1) and the draft tree is initialized randomly. Additional analyses of sampling strategies and initialization are provided in Appendices A and B. 4.2 Results 4.2.1 Main Results MT-Bench L2-7B L2-13B L3-8B Q2-7B Q2-14B Q2-32B Q3-8B Q3-14B AR (Ref.) 1.00× (39± 3.9) 1.00× (24± 1.7) 1.00× (38± 2.6) 1.00× (36± 4.3) 1.00× (20± 1.9) 1.00× (10± 0.6) 1.00× (39± 3.4) 1.00× (24± 1.3) LADE 1.49× (58± 9.8) 1.38× (33± 4.9) 1.42× (54± 5.2) 1.42× (51± 8.8) 1.45× (29± 5.0) 1.60× (16± 3.0) 1.51× (59± 7.3) 1.29× (31± 4.7) Self-Draft 1.54× (60± 12.1) 1.54× (37± 6.6) 1.53× (58± 7.9) 1.47× (53± 12.5) 1.50× (30± 6.6) 1.60× (16± 3.3) 1.54× (60± 9.5) 1.38× (33± 5.1) PTD (Ours) 1.67× (65± 11.1) 1.67× (40± 5.8) 1.66× (63± 7.1) 1.69× (61± 15.4) 1.75× (35± 7.6) 1.90× (19± 3.9) 1.64× (64± 6.9) 1.54× (37± 6.2) GSM-100 L2-7B L2-13B L3-8B Q2-7B Q2-14B Q2-32B Q3-8B Q3-14B AR (Ref.) 1.00× (43± 0.9) 1.00× (26± 0.4) 1.00× (41± 0.6) 1.00× (39± 1.9) 1.00× (22± 0.5) 1.00× (10± 0.2) 1.00× (40± 1.3) 1.00× (25± 0.6) LADE 1.70× (73± 5.6) 1.58× (41± 3.3) 1.71× (70± 5.2) 1.56× (61± 6.3) 1.55× (34± 3.8) 1.80× (18± 1.5) 1.73× (69± 5.9) 1.44× (36± 2.7) Self-Draft 1.72× (74± 6.2) 1.69× (44± 4.5) 1.80× (74± 5.0) 1.56× (61± 7.4) 1.59× (35± 4.2) 1.90× (19± 1.6) 1.83× (73± 5.7) 1.52× (38± 3.8) PTD (Ours) 1.91× (82± 7.5) 1.85× (48± 4.2) 1.93× (79± 6.7) 1.87× (73± 13.3) 1.86× (41± 5.9) 2.30× (23± 2.1) 1.93× (77± 9.4) 1.76× (44± 5.2) Table 1: Speedup performance on MT-Bench and GSM-100 across Llama and Qwen model series. The primary metric is the Speedup Ratio (n×n×), with throughput (tokens/s) and standard deviation shown in small parentheses. Method HumanEval MBPP-100 CL-7B CL-13B CL-7B CL-13B AR (Ref.) 1.00× (42± 1.6) 1.00× (25± 0.7) 1.00× (44± 0.8) 1.00× (26± 0.3) LADE 1.45× (61± 5.7) 1.44× (36± 4.6) 1.70× (75± 7.5) 1.65× (43± 4.1) Self-Draft 1.62× (68± 7.4) 1.68× (42± 5.4) 1.86× (82± 6.7) 1.88× (49± 4.3) PTD 1.69× (71± 7.4) 1.72× (43± 5.6) 2.05× (90± 8.9) 2.08× (54± 5.4) Table 2: Speedup and throughput results on code generation benchmarks. The format follows: Speedup×Speedup× (Throughput ± Std). Tables 1 and 2 summarize the speedup performance. We set the maximum tree depth to 6 and the branching factor to 4. As observed, PTD consistently achieves the highest speedup across all evaluated models and tasks, outperforming state-of-the-art training-free baselines like LADE and Self-Draft. The advantages of PTD are most pronounced in reasoning-intensive benchmarks, specifically GSM-100 (up to 2.30×) and MBPP-100 (up to 2.08×). Because mathematical and coding tasks follow structured logical paths, PTD’s tree-based evolution effectively maintains high draft coherence while providing broader coverage of the solution space, significantly reducing redundant computations compared to independent branching methods. Moreover, PTD achieves stable acceleration across various model generations (from LLaMA-2 to Qwen-3) as a training-free, plug-and-play solution. Whether applied to smaller 7B models or the larger Qwen2-32B (reaching a peak speedup of 2.30×), PTD consistently unlocks the model’s inherent parallel potential with zero extra learning cost, proving its superior versatility in real-world deployment. Figure 5: Draft content quality analysis. Figure 5 provides a more in-depth analysis of decoding efficiency(DE), hit rate(HR), candidate draft acceptance length(AL), and overhead(Dft/Ver), which reveals the underlying causes of speed differences among the methods. On this front, PTD demonstrates a comprehensive advantage. Specifically, while PTD exhibits a slightly lower HR compared to Self-Draft, which primarily because Self-Draft uses specific external data/corpora to boost hit probability, it maintains a substantial lead in AL. This indicates that PTD-generated drafts possess superior contextual coherence, allowing the model to accept much longer sequences per verification pass. Furthermore, PTD maintains a competitive overhead profile, comparable to Self-Draft and generally lower than LADE. This ensures that the structural complexity of PTD does not translate into significant latency during the forward pass, effectively maximizing the net gain in inference speed. A detailed runtime breakdown is provided in Appendix C. 4.2.2 Draft Tree Analysis The performance of PTD is governed by the trade-off between draft quality and computational overhead. Figure 6 analyzes the effects of the maximum number of child nodes (w) and drafting depth (d). Impact of Max Child Nodes (w). With depth fixed at 6, increasing w improves both Hit Rate (HRHR) and Accept Length (ALAL) by expanding the search breadth and increasing the chance of covering the intended semantic path. However, throughput follows a rise-then-fall trend and peaks at w=4w=4, after which the additional latency of a wider tree outweighs the gains in HRHR and ALAL. Impact of Max Drafting Depth (d). With w=4w=4, HRHR remains relatively stable as depth increases, suggesting that the initial hit is driven more by branching diversity than depth. In contrast, ALAL keeps increasing because deeper trees allow longer continuation along a correct path. Throughput peaks at d=6d=6, beyond which the benefit of longer accepted sequences is offset by the overhead of verifying deeper trees. Overall, PTD exhibits strong robustness across a broad range of tree configurations. In practical deployments, w and d can be dynamically adapted based on specific model architectures and hardware resources. In this paper, we utilize a uniform configuration of w=4w=4 and d=6d=6 to facilitate a consistent discussion across all evaluations. Figure 6: Effect of tree width and depth on PTD performance on LLaMA-7B. Figure 7: Draft efficiency of LADE and PTD on LLaMA-7B and LLaMA-13B. 4.2.3 Draft efficiency Figure 7 compares the drafting efficiency of PTD and LADE across different computational overhead levels. PTD consistently achieves higher throughput (TP) and decoding efficiency (DE). On LLaMA-7B, PTD matches LADE’s peak throughput with approximately half the overhead; on LLaMA-13B, it requires only about one-third. PTD also provides substantial speedups under low-overhead settings, highlighting its potential for large-scale inference services. Additional evaluations of generation quality under sampling and acceleration under greedy decoding are provided in Appendices G and H. 5 Conclusion In this paper, we introduce PTD, a guided and structured inference acceleration method for autoregressive LLMs. This framework achieves comprehensive performance gains across diverse models and benchmarks as a training-free and model-agnostic solution. Future research will explore dense semantic representations, like semantic graphs, to enable more guided and efficient draft generation beyond current tree-based methods. Besides, we also aim to decouple the drafting and decoding processes to enhance system efficiency and scalability. References Ankner et al. (2024) Zachary Ankner, Rishab Parthasarathy, Aniruddha Nrusimha, Christopher Rinard, Jonathan Ragan-Kelley, and William Brandon. Hydra: Sequentially-dependent draft heads for medusa decoding, 2024. URL https://arxiv.org/abs/2402.05109. Austin et al. (2021) Jacob Austin, Augustus Odena, Maxwell Nye, Maarten Bosma, Henryk Michalewski, David Dohan, Ellen Jiang, Carrie Cai, Michael Terry, Quoc Le, et al. Program synthesis with large language models. arXiv preprint arXiv:2108.07732, 2021. Bachmann et al. (2025) Gregor Bachmann, Sotiris Anagnostidis, Albert Pumarola, Markos Georgopoulos, Artsiom Sanakoyeu, Yuming Du, Edgar Schönfeld, Ali Thabet, and Jonas Kohler. Judge decoding: Faster speculative sampling requires going beyond model alignment, 2025. URL https://arxiv.org/abs/2501.19309. Cai et al. (2024) Tianle Cai, Yuhong Li, Zhengyang Geng, Hongwu Peng, Jason D. Lee, Deming Chen, and Tri Dao. Medusa: Simple llm inference acceleration framework with multiple decoding heads, 2024. Chen et al. (2023) Charlie Chen, Sebastian Borgeaud, Geoffrey Irving, Jean-Baptiste Lespiau, Laurent Sifre, and John Jumper. Accelerating large language model decoding with speculative sampling, 2023. Chen et al. (2021) Mark Chen, Jerry Tworek, Heewoo Jun, Qiming Yuan, Henrique Ponde de Oliveira Pinto, Jared Kaplan, Harri Edwards, Yuri Burda, Nicholas Joseph, Greg Brockman, Alex Ray, Raul Puri, Gretchen Krueger, Michael Petrov, Heidy Khlaaf, Girish Sastry, Pamela Mishkin, Brooke Chan, Scott Gray, Nick Ryder, Mikhail Pavlov, Alethea Power, Lukasz Kaiser, Mohammad Bavarian, Clemens Winter, Philippe Tillet, Felipe Petroski Such, Dave Cummings, Matthias Plappert, Fotios Chantzis, Elizabeth Barnes, Ariel Herbert-Voss, William Hebgen Guss, Alex Nichol, Alex Paino, Nikolas Tezak, Jie Tang, Igor Babuschkin, Suchir Balaji, Shantanu Jain, William Saunders, Christopher Hesse, Andrew N. Carr, Jan Leike, Josh Achiam, Vedant Misra, Evan Morikawa, Alec Radford, Matthew Knight, Miles Brundage, Mira Murati, Katie Mayer, Peter Welinder, Bob McGrew, Dario Amodei, Sam McCandlish, Ilya Sutskever, and Wojciech Zaremba. Evaluating large language models trained on code, 2021. Cobbe et al. (2021) Karl Cobbe, Vineet Kosaraju, Mohammad Bavarian, Mark Chen, Heewoo Jun, Lukasz Kaiser, Matthias Plappert, Jerry Tworek, Jacob Hilton, Reiichiro Nakano, Christopher Hesse, and John Schulman. Training verifiers to solve math word problems. arXiv preprint arXiv:2110.14168, 2021. Fu et al. (2024) Yichao Fu, Peter Bailis, Ion Stoica, and Hao Zhang. Break the sequential dependency of llm inference using lookahead decoding, 2024. Gao et al. (2025) Zipeng Gao, Qingrong Xia, Tong Xu, Xinyu Duan, Zhi Zheng, Zhefeng Wang, and Enhong Chen. Multi-branch self-drafting for llm inference acceleration. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 39, p. 23942–23950, 2025. He et al. (2023) Zhenyu He, Zexuan Zhong, Tianle Cai, Jason D Lee, and Di He. Rest: Retrieval-based speculative decoding, 2023. Leviathan et al. (2023) Yaniv Leviathan, Matan Kalman, and Yossi Matias. Fast inference from transformers via speculative decoding, 2023. Li et al. (2024a) Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. Eagle: speculative sampling requires rethinking feature uncertainty. In Proceedings of the 41st International Conference on Machine Learning, ICML’24. JMLR.org, 2024a. Li et al. (2024b) Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. Eagle-2: Faster inference of language models with dynamic draft trees, 2024b. URL https://arxiv.org/abs/2406.16858. Li et al. (2025) Yuhui Li, Fangyun Wei, Chao Zhang, and Hongyang Zhang. Eagle: Speculative sampling requires rethinking feature uncertainty, 2025. URL https://arxiv.org/abs/2401.15077. Liu et al. (2025) Tianyu Liu, Yun Li, Qitan Lv, Kai Liu, Jianchen Zhu, Winston Hu, and Xiao Sun. Pearl: Parallel speculative decoding with adaptive draft length, 2025. URL https://arxiv.org/abs/2408.11850. Miao et al. (2024) Xupeng Miao, Gabriele Oliaro, Zhihao Zhang, Xinhao Cheng, Zeyu Wang, Zhengxin Zhang, Rae Ying Yee Wong, Alan Zhu, Lijie Yang, Xiaoxiang Shi, Chunan Shi, Zhuoming Chen, Daiyaan Arfeen, Reyna Abhyankar, and Zhihao Jia. Specinfer: Accelerating large language model serving with tree-based speculative inference and verification. In Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 3, ASPLOS ’24, p. 932–949. ACM, April 2024. doi: 10.1145/3620666.3651335. URL http://dx.doi.org/10.1145/3620666.3651335. Stern et al. (2018) Mitchell Stern, Noam Shazeer, and Jakob Uszkoreit. Blockwise parallel decoding for deep autoregressive models. Advances in Neural Information Processing Systems, 31, 2018. Xia et al. (2023) Heming Xia, Tao Ge, Peiyi Wang, Si-Qing Chen, Furu Wei, and Zhifang Sui. Speculative decoding: Exploiting speculative execution for accelerating seq2seq generation. In Houda Bouamor, Juan Pino, and Kalika Bali (eds.), Findings of the Association for Computational Linguistics: EMNLP 2023, p. 3909–3925, Singapore, December 2023. Association for Computational Linguistics. doi: 10.18653/v1/2023.findings-emnlp.257. URL https://aclanthology.org/2023.findings-emnlp.257/. Xia et al. (2024) Heming Xia, Zhe Yang, Qingxiu Dong, Peiyi Wang, Yongqi Li, Tao Ge, Tianyu Liu, Wenjie Li, and Zhifang Sui. Unlocking efficiency in large language model inference: A comprehensive survey of speculative decoding. In Lun-Wei Ku, Andre Martins, and Vivek Srikumar (eds.), Findings of the Association for Computational Linguistics: ACL 2024, p. 7655–7671, Bangkok, Thailand, August 2024. Association for Computational Linguistics. doi: 10.18653/v1/2024.findings-acl.456. URL https://aclanthology.org/2024.findings-acl.456/. Yang et al. (2024) Sen Yang, Shujian Huang, Xinyu Dai, and Jiajun Chen. Multi-candidate speculative decoding. arXiv preprint arXiv:2401.06706, 2024. Yuan et al. (2024) Zhihang Yuan, Yuzhang Shang, Yang Zhou, Zhen Dong, Zhe Zhou, Chenhao Xue, Bingzhe Wu, Zhikai Li, Qingyi Gu, Yong Jae Lee, Yan Yan, Beidi Chen, Guangyu Sun, and Kurt Keutzer. Llm inference unveiled: Survey and roofline model insights, 2024. Zhang et al. (2025) Ziyi Zhang, Ziheng Jiang, Chengquan Jiang, Menghan Yu, Size Zheng, Haibin Lin, Henry Hoffmann, and Xin Liu. Swiftspec: Ultra-low latency llm decoding by scaling asynchronous speculative decoding, 2025. URL https://arxiv.org/abs/2506.11309. Zheng et al. (2023) Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric P. Xing, Hao Zhang, Joseph E. Gonzalez, and Ion Stoica. Judging llm-as-a-judge with mt-bench and chatbot arena, 2023. Appendix A Sample Strategy for the Draft Tree Expansion This section analyzes how the draft-tree expansion strategy affects PTD. Unless otherwise noted, we use LLaMA-2-13B on MT-Bench and compare greedy expansion with top-k and top-p sampling for draft-tree growth. For sampled expansion, we first obtain the top-k or top-p distribution at each node and then sample draft tokens from that distribution to extend the tree. Figure 8 shows the resulting trade-off. Compared with greedy expansion, top-k and top-p increase overhead because they introduce greater diversity and uncertainty, which leads to faster tree growth. However, the additional overhead yields little improvement in throughput or decoding efficiency. Figure 8: PTD performance under different sampling strategies for draft tree expansion. Appendix B Impact of Initialization Strategy This section compares random initialization with a Named Entity Recognition (NER)-based initialization strategy for PTD across the eight MT-Bench categories. As shown in Figure 9, the effectiveness of the initialization strategy depends on the task type. For structured domains such as coding, mathematics, and extraction, NER-based initialization performs better because entity-aware seeds better capture task-specific identifiers and core logical elements. In contrast, the difference between the two methods is small for open-ended tasks such as creative writing. These results suggest that specialized initialization is most useful for structured reasoning and less critical for general-purpose generation. Figure 9: Performance comparison of PTD under random and NER-based initialization across eight MT-Bench tasks. Appendix C Overhead Analysis This section breaks down the runtime overhead of PTD relative to autoregressive decoding on Qwen models. PTD introduces three additional costs: candidate-tree retrieval before the forward pass, parallel drafting and verification during the forward pass, and candidate-pool and draft-tree updates after the forward pass. Figure 10 shows that the dominant overhead comes from the forward pass, where PTD performs additional inference on both the draft tree and the candidate tree, while retrieval and update costs remain negligible. Figure 10: Run time analysis for Qwen models. Appendix D Progressive Tree Drafting Decoding Algorithm Algorithm 1 Progressive Tree Drafting Decoding Algorithm 1: Input: Prompt =[x1,x2,…,xt−1]X=[x_1,x_2,...,x_t-1]; max tree depth dmaxd_max; initial tree T0=(V0,E0)T^0=(V^0,E^0); max length N 2: while True do 3: Step 1: Retrieve Candidate Tree 4: Retrieve candidate tree ←C_X← RetrieveCandidateTree(X) 5: Step 2: Generate Next Token(s) with Structural Guidance 6: xt,,←(P(yt,T,∣[;Ti−1;]))x_t,D,V (P(y_t,y_T,y_C [X;T^i-1;C_X ]) ) 7: Step 3: Expand the Draft Tree 8: Vi←Vi−1∪dv∣∀v∈Vi−1V^i← V^i-1∪\d_v ∀ v∈ V^i-1\ 9: Ei←Ei−1∪(v,dv)∣∀v∈Vi−1E^i← E^i-1∪\(v,d_v) ∀ v∈ V^i-1\ 10: if depth(Ti)>dmaxdepth(T^i)>d_max then 11: Ti←T^i← StepAndPrune(TiT^i) 12: end if 13: Step 4: Merge Subtrees into Candidate Pool 14: for each subtree Ts′T _s in TiT^i do 15: Update candidate pool by merging trees using ℳM 16: end for 17: Step 5: Obtain Eligible Edges 18: if Using Greedy Decoding then 19: ←argmax(P)V (P_C) 20: ℰ←(n,n)∣n∈σ(n),∀n∈ViE←\(n,V_n) _n∈σ(n),∀ n∈ V^i\ 21: else if Using Sampling Decoding then 22: ℰ,nk←E,V_n_k← CandidateTreeRecursiveSample(C_X) 23: end if 24: Step 6: Append Chosen Path 25: ′←(n0,n1,…,nk,nk)X ←(n_0,n_1,...,n_k,V_n_k) s.t. ∀i<k,(ni,ni+1)∈ℰ∀ i<k,(n_i,n_i+1) 26: Append ′X to X 27: if ||>N|X|>N then 28: break 29: end if 30: i←i+1i← i+1 31: end while 32: Output: Generated sequence X Appendix E Candidate Tree Recursive Sampling Algorithm Algorithm 2 Candidate Tree Recursive Sampling 1: Input: A node v 2: Output: Obtain global eligible edges ℰE 3: C←σ(v)C←σ(v) Children of v 4: while C is not empty do 5: for all n∈Cn∈ C do 6: Sample r∼(0,1)r (0,1) 7: if r<P(n)r<P(n) then 8: Append (v,n)(v,n) to ℰE 9: call nk←V_n_k← Traversal(n)(n) 10: return nkn_k 11: else 12: P[n]←0P[n]← 0 13: Renormalize P over remaining nodes in C 14: end if 15: end for 16: end while 17: If no child selected, sampling based on current node distribution 18: return (P(v))S (P(v) ) Appendix F Proof of Distributional Consistency of the Candidate Tree Recursive Sampling Algorithm We aim to prove that the sampling algorithm described in Appendix D selects each candidate node nin_i with probability equal to its original probability PiP_i. Sampling Procedure. Given a set of candidate nodes n1,n2,…,nk\n_1,n_2,…,n_k\ and associated probabilities PiP_i, the algorithm iteratively samples a random variable r∼(0,1)r (0,1) and accepts the first node nin_i such that r<Pir<P_i (after re-normalization, if any earlier nodes have been rejected). If nin_i is not accepted, its probability is set to 0, and the remaining probabilities are re-normalized. Objective. Let iA_i denote the event that node nin_i is selected. We aim to prove: ℙ(i)=Pi,∀i∈1,2,…,k.P(A_i)=P_i, ∀ i∈\1,2,…,k\. Base Case (i=1i=1). Node n1n_1 is the first candidate considered. Since no re-normalization has occurred yet, its acceptance probability is: ℙ(1)=ℙ(r<P1)=P1.P(A_1)=P(r<P_1)=P_1. Inductive Step. Suppose that for each j<ij<i, the probability of selecting node njn_j is exactly PjP_j, and the algorithm correctly rejects n1n_1 through ni−1n_i-1 with total probability Ri−1=∑j=1i−1PjR_i-1= _j=1^i-1P_j. After rejecting n1,…,ni−1n_1,…,n_i-1, the remaining unnormalized probability is: Si−1=1−∑j=1i−1Pj.S_i-1=1- _j=1^i-1P_j. The normalized probability of nin_i in this residual distribution becomes: P^i=PiSi−1. P_i= P_iS_i-1. The probability of reaching nin_i without accepting any of the previous i−1i-1 nodes is: ℙ(reaching ni)=∏j=1i−1(1−P^j).P(reaching n_i)= _j=1^i-1(1- P_j). However, since: ∏j=1i−1(1−P^j)=∏j=1i−1(1−PjSj−1)=S1S0⋅S2S1⋯Si−1Si−2=Si−1S0=Si−1, _j=1^i-1(1- P_j)= _j=1^i-1 (1- P_jS_j-1 )= S_1S_0· S_2S_1·s S_i-1S_i-2= S_i-1S_0=S_i-1, and S0=1S_0=1, this implies: ℙ(reaching ni)=Si−1.P(reaching n_i)=S_i-1. Therefore, the total probability of accepting nin_i is: ℙ(i)=ℙ(reaching ni)⋅P^i=Si−1⋅PiSi−1=Pi.P(A_i)=P(reaching n_i)· P_i=S_i-1· P_iS_i-1=P_i. Conclusion. By induction, for every i∈1,…,ki∈\1,…,k\, the probability of node nin_i being selected is exactly PiP_i. Hence, the sampling algorithm yields a sample from the original distribution P: ℙ(i)=Pi∀i.P(A_i)=P_i ∀ i. This proves that the sequential rejection-normalization sampling procedure preserves the target distribution. Appendix G Generation Quality Evaluation: A Comparison Between PTD and Autoregressive Decoding under the Sampling Strategy This section compares the generated content of PTD and standard autoregressive decoding under the sampling setting. We evaluate MT-Bench, GSM-100, HumanEval, and MBPP-100 with LLaMA-2 (L), Qwen-2.5 (Q), and CodeLLaMA (CL) models using Rouge-1, Rouge-2, Rouge-L, and BLEU. Benchmark Model Rouge-1 Rouge-2 Rouge-L BLEU MT-Bench L-7B 50 32 34 17 L-13B 51 34 36 19 Q-7B 42 20 24 21 Q-14B 48 22 24 18 Q-32B 48 24 26 22 GSM-100 L-7B 68 53 55 39 L-13B 65 50 53 36 Q-7B 49 31 34 26 Q-14B 52 29 31 28 Q-32B 58 40 41 38 HumanEval CL-7B 48 38 40 26 CL-13B 48 40 43 21 MBPP-100 CL-7B 82 77 80 77 CL-13B 82 78 80 76 Table 3: Comparison of generated content between PTD and autoregressive decoding under the sampling strategy. L, Q, and CL denote LLaMA-2, Qwen-2.5, and CodeLLaMA, respectively. Appendix H Acceleration Performance of Greedy Decoding Strategy This section reports acceleration results under greedy decoding on MT-Bench, GSM-100, HumanEval, and MBPP-100 using LLaMA-2 (L), Qwen-2.5 (Q), and CodeLLaMA (CL) models. Benchmark Model AR LADE Self-Draft PTD TP(Std) TP(Std) Imp. TP(Std) Imp. TP(Std) Imp. MT-Bench L-7B 40± 4.1 59± 9.4 47% 62± 11.4 56% 67± 10.8 68% L-13B 24± 1.7 34± 4.8 41% 37± 6.7 54% 40± 6.4 67% Q-7B 36± 4.4 59± 12.2 65% 55± 13.4 52% 70± 20.0 93% Q-14B 20± 2.0 31± 5.3 57% 31± 6.3 56% 36± 6.8 81% Q-32B 10± 0.6 16± 2.7 57% 16± 3.3 62% 19± 3.6 88% GSM-100 L-7B 44± 1.0 74± 5.9 66% 75± 6.7 68% 85± 7.2 91% L-13B 26± 0.4 41± 3.3 58% 44± 4.6 67% 49± 4.3 89% Q-7B 40± 2.1 72± 8.2 80% 65± 8.8 62% 86± 16.4 116% Q-14B 22± 0.6 37± 3.7 67% 37± 4.6 69% 44± 5.2 99% Q-32B 11± 0.2 19± 1.6 81% 19± 1.2 82% 24± 2.2 125% HumanEval CL-7B 43± 1.7 62± 6.8 45% 62± 7.6 45% 74± 8.5 74% CL-13B 25± 0.7 37± 4.5 45% 39± 5.3 55% 44± 5.8 74% MBPP-100 CL-7B 45± 0.8 77± 6.4 71% 73± 7.2 62% 93± 9.9 108% CL-13B 26± 0.3 43± 4.1 64% 48± 4.5 82% 55± 5.4 107% Table 4: Throughput and relative improvement (Imp.) under greedy decoding for autoregressive decoding (AR), LADE, Self-Draft, and PTD. L, Q, and CL denote LLaMA-2, Qwen-2.5, and CodeLLaMA, respectively. Benchmark Model LADE Self-Draft PTD DE HR AL Dft/Ver DE HR AL Dft/Ver DE HR AL Dft/Ver MT-Bench L-7B 1.95 0.69 2.39 59/23 1.96 0.95 2.02 30/30 2.23 0.71 2.74 35/23 L-13B 1.83 0.67 2.26 39/17 1.96 0.95 2.02 30/30 2.20 0.71 2.70 34/22 Q-7B 2.20 0.78 2.55 59/31 2.03 0.92 2.12 31/26 2.58 0.80 2.99 40/29 Q-14B 2.01 0.76 2.31 39/21 1.97 0.92 2.05 31/26 2.40 0.80 2.76 42/29 Q-32B 1.87 0.72 2.21 27/15 2.02 0.92 2.11 31/25 2.43 0.77 2.86 37/27 GSM-100 L-7B 2.23 0.72 2.72 58/22 2.29 0.94 2.38 30/32 2.52 0.73 3.09 32/21 L-13B 2.06 0.70 2.53 38/16 2.29 0.94 2.38 30/32 2.48 0.72 3.05 31/20 Q-7B 2.44 0.83 2.75 59/35 2.25 0.95 2.32 31/28 2.90 0.84 3.26 37/31 Q-14B 2.16 0.80 2.45 39/23 2.19 0.95 2.25 31/28 2.68 0.84 3.00 41/32 Q-32B 2.16 0.80 2.46 27/17 2.34 0.96 2.40 31/29 2.91 0.84 3.28 35/30 HumanEval CL-7B 1.96 0.67 2.44 58/20 2.15 0.94 2.24 30/30 2.35 0.69 2.97 33/19 CL-13B 1.95 0.66 2.45 38/15 2.23 0.93 2.33 30/29 2.35 0.68 3.00 31/17 MBPP-100 CL-7B 2.29 0.71 2.82 58/23 2.47 0.94 2.57 30/30 2.75 0.74 3.36 33/20 CL-13B 2.13 0.69 2.63 38/16 2.48 0.94 2.59 30/30 2.72 0.74 3.34 32/19 Table 5: Decoding efficiency (DE), hit rate (HR), Accept Length (AL), and overheads (Dft/Ver) of PTD, LADE, and Self-Draft under greedy decoding.