Speculative Streaming: Fast LLM Inference without Auxiliary Models

## Abstract

Abstract Speculative decoding is a prominent technique to speed up the inference of a large target language model based on predictions of an auxiliary draft model. While effective, in application-specific settings, it often involves fine-tuning both draft and target models to achieve high acceptance rates. As the number of downstream tasks grows, these draft models add significant complexity to inference systems. We propose Speculative Streaming, a single-model speculative decoding method that fuses drafting into the target model by changing the fine-tuning objective from next token prediction to future n-gram prediction. Speculative Streaming speeds up decoding by 1.8 - 3.1X in a diverse set of tasks, such as Summarization, Structured Queries, and Meaning Representation, without sacrificing generation quality. Additionally, Speculative Streaming is parameter-efficient. It achieves on-par/higher speed-ups than Medusa-style architectures while using ∼ similar-to \sim ∼ 10000X fewer extra parameters, making it well-suited for resource-constrained devices.

## 1 Introduction

Large transformers are today’s preeminent tool for language modeling. The quality of these models improves as they scale (Kaplan et al., ), leading to the introduction of the state-of-the-art multi-billion parameter models (Brown et al., ; Thoppilan et al., ; Chowdhery et al., ; Touvron et al., ). While these models are very effective for token generation, they incur a high inference cost as the model and its transient states need to be loaded into computing memory for each subsequently generated token. Moreover, scaling up these models, besides making each call more compute-intensive, also makes their autoregressive generation memory bound (Pope et al., ), preventing them from making effective use of available compute. This poses a significant challenge to the deployment of large autoregressive transformers,
particularly for user-facing applications with tight latency requirements.

Given the memory-bound nature of large language model (LLM) inference, recent work (Leviathan et al., ; Chen et al., ) proposed Speculative Decoding as an effective technique to accelerate decoding based on concepts borrowed from speculative computation (Burton, ) to exploit the available extra compute.
The core of speculative decoding is the idea of speculating multiple candidate future tokens first, and then verifying them all in parallel. To achieve this, as shown in Figure 1(a), a two-model paradigm approach is used: a small auxiliary “draft” model for candidate speculation and a large “target” model for verification (Leviathan et al., ; Chen et al., ).
Although effective in accelerating LLMs, speculative decoding complicates deployment. Training also becomes more demanding and complicated, as a separate draft model needs to be trained and aligned with the target model. It is also not resource-efficient, requiring to host two models in memory during token prediction. This increased footprint is especially unsatisfactory for resource-constrained devices.

In this paper, we propose Speculative Streaming, a single-model speculative decoding approach that unifies speculation and verification, obviating the need for a separate draft model as shown in Figure 1(b). This is accomplished by incorporating multi-stream attention into the target model to perform n-gram prediction which serves as future candidate speculation. As a result, a forward model pass can verify the previously generated tokens while simultaneously speculating on the future tokens. Moreover, compared to previous approaches, Speculative Streaming is trained end-to-end, naturally aligning speculation and verification phases.

While making the system significantly simpler and resource efficient, Speculative Streaming achieves speedups comparable to two-stage speculative decoding (Leviathan et al., ) without degrading the quality metrics on a diverse set of downstream tasks. It also leads to on-par or better speedup than the more recent block-wise decoding model, Medusa (Cai et al., ), that introduces multiple additional high-dimensional prediction heads. Moreover, Speculative Streaming requires 10000X fewer additional parameters than Medusa(Cai et al., ), which makes it an ideal method for resource-constrained devices.

In summary, the advantages of Speculative Streaming are as follows:

- –
Achieving substantial speedups through streamlined fine-tuning and eliminating the need for a separate draft model.
- –
Demonstrating resource efficiency with 10000X fewer extra parameters compared to  (Cai et al., ) while achieving better speedups, all without compromising quality across a diverse range of tasks.
- –
Simplifying deployment processes by eliminating the need to manage, align, and switch between two models during execution, as observed in (Leviathan et al., ).

## 2 Related Works

The inference of large language models is often limited by the sequential nature of auto-regressive decoding, where each token generation requires a complete network forward pass. Several approaches have been proposed to address the high inference latency of large language models by directly decreasing the memory footprint of LLMs. Model quantization (Frantar et al., ; Yao et al., ; Dettmers et al., ), knowledge distillation to a smaller a model (Gu et al., ; Agarwal et al., ), and pruning (Frantar & Alistarh, ; Sun et al., ) are among these techniques.
Recently, speculative decoding (SD) has emerged as a vital technique to accelerate autoregressive decoding.

The original speculative decoding approach (Chen et al., ; Leviathan et al., ) utilizes a smaller
LLM (\akathe *draft model*), to generate a candidate sequence of tokens to be verified by the *target model*.
With a well-tuned draft model, this technique can achieve a 2-3x inference speedup.
Recent SD variants propose parallel computation along the batch axis (Sun et al., ), and tree-structured batches (Miao et al., ; Spector & Re, ) to improve the acceptance rates of the guessed tokens by the target model and to further boost the performance.
However, these methods encounter a common limitation: the necessity of developing an accurate and independent draft model.
First, training such a draft model aligned with the main model is not trivial (Zhou et al., ).
Second, hosting two different models increases the system complexity, and is more computationally and operationally expensive to maintain.

Figure: Figure 2: Architecture: We replace top $N_{s}$ multi-head attention (MHA) layers of the base model with multi-stream attention (MSA) layers as described in (2). Speculative streams are initialized using hidden states of layer $N-N_{s}$ and stream identifier embeddings (SE), as described in (3) and used to generate speculative draft in the form of a tree. The speculative tree draft from the previous iteration is batched for verification and pruned before stream insertion. During each forward pass previous tree draft is verified and a new tree draft is issued using speculative streams as described in 3.2.2
Refer to caption: x2.png

Very recently, single-model speculation has also been considered.
In particular, inspired by (Qi et al., ; Stern et al., ), Medusa (Cai et al., ) extends the main model to predict future tokens in parallel by training multiple output heads.
While it does not require a draft model, each Medusa head of size (*hidden_size* $\times$ *vocab_size*) requires nonnegotiable additional parameters. As auto-regressive generation typically follows a memory-bound compute pattern, the significant amount of extra parameters introduces deployment challenges on resource-constrained devices. Alternatively, lookahead decoding (Fu et al., ) proposes a parallel decoding method without learning new parameters.
It uses Jacobi Decoding and n-gram history trajectory cache to generate and verify future n-gram prediction.
Differently, Speculative Streaming achieves n-gram generation by learning a set of token embeddings and accelerates decoding by running speculation and verification concurrently. Notably, our approach can achieve better speedup with significantly less number of extra parameters compared to the existing speculative decoding methods (Chen et al., ; Leviathan et al., ; Cai et al., ), while simplifying on-device deployment.

## 3 Method

### 3.1 Motivation

Most speculative decoding approaches exhibit a distinct separation in the training processes of draft and target models. However, directly using an off-the-shelf draft model often leads to sub-optimal performance in many downstream applications. The speculated tokens frequently fail the verification of the target model when draft and target models are misaligned. To achieve improved speedups, fine-tuning both draft and target models on downstream applications becomes necessary. Our objective is to devise an end-to-end trainable single-model framework capable of simultaneously predicting the next token and speculating future tokens. This eliminates the need for an auxiliary draft model while achieving speedups similar to those reported in (Leviathan et al., ). We aim to attain this speedup by increasing the arithmetic intensity of auto-regressive transformer calls without compromising generation quality.

### 3.2 Speculative Streaming

We propose Speculative Streaming to enable parameter efficient speculative fine-tuning and inference of decoder-only models on downstream applications. Compared to the standard draft-target speculative decoding (Leviathan et al., ) and more recently proposed block-wise decoding (Cai et al., ), Speculative Streaming introduces the following modifications. (a) Speculative stream design and initialization as described in  Section 3.2.1 (c) Parallel speculation and verification as described in Section 3.2.2 (d) Parallel tree draft pruning, described in Section 3.2.3 and finally (e) Training objective as described in Section 3.2.4.

#### 3.2.1 Streams Design and Initialization

Parameter efficient fine-tuning (Hu et al., ) of decoder-only pre-trained language models involves training low-rank adapters to predict next target token $y_{t}$ given context tokens $(x_{1}....x_{m})$ and previous target tokens $(y_{1}..y_{<t})$ on downstream applications. To inherently embed a notion of future token planning, we modify the training objective of the target model from next token prediction to n-gram prediction using the concept of multi-stream attention (Qi et al., ; Yang et al., ). This objective allows the model to plan for future tokens and prevent over-fitting on local correlations. In addition, each of the $\gamma$ streams generates speculative tokens with negligible latency overhead when the model is memory-bound. Specifically, each added stream predicts $p({y_{t+j}|y_{<t},x)},$ where $1<=j<=\gamma$, while main stream predicts $p({y_{t}|y_{<t},x})$. We refer to the multi-head attention mechanism depicted in (Vaswani et al., ) as main-stream self-attention and introduce $\gamma$ additional self-attention streams to speculate future tokens.

The attention mechanism of main stream is the same as standard multi-head attention (Vaswani et al., ).

$$ $M_{t}^{k+1}=\text{MHA}(M_{t}^{k},M_{\leq t}^{k},M_{\leq t}^{k})$ (1) $$

Where $M_{t}^{k}$ denotes hidden states of main stream at layer $k$ and time step $t$ and $MHA(H,H,H)$ denotes attention between query $HW^{Q}$, key $HW^{K}$ and value $HW^{V}$ as described in (Vaswani et al., ).
On the other hand, each speculative stream $j$ at time step $t$ attends to previous main stream hidden states as well as speculative stream hidden states as:

$$ $S_{tj}^{k+1}=\text{MHA}(S_{tj}^{k},M_{\leq t}^{k}\oplus S_{t(\leq j)}^{k},M_{ \leq t}^{k}\oplus S_{t(\leq j)}^{k})$ (2) $$

where $M_{t}^{k+1}$ and $S_{t}^{k+1}$ refer to main and speculative streams at time step $t$ and layer $k$. Hidden state of last transformer layer $N$, $M_{t}^{N}$ is used to predict $y_{t}$, whereas each speculative stream at last layer, $S_{tj}^{N}$ predicts $y_{t+j}$. We refer to layers incorporating the attention mechanism in  Equation 1 as MHA layers while layers incorporating speculative stream attention  Equation 2 are referred to as MSA layers.

Key/value projections of main stream hidden states are cached during inference to avoid re-computation, whereas, speculative stream attention is specifically designed to avoid storing additional key/value projections associated with individual streams. This is because speculative streams are trained to learn contextual features from main stream key/value context allowing us to not introduce additional caching overhead and operate within memory bounds of resource-constrained devices during inference. We initialize hidden states of speculative streams at layer $N-N_{s}$ instead of initializing them from the embedding layer, where $N_{s}<N$. Specifically, stream $j$ at time $t$ is initialized at layer $N-N_{s}$ as,

$$ $S_{tj}^{N-N_{s}}=f_{\eta}(M_{t}^{N-Ns})+P_{j}^{N-N_{s}}$ (3) $$

where $P_{j}$ is a stream identifier embedding that embeds a sense of relative position into streams and distinguishes the computation from main stream.
$f_{\eta}$ is a linear transformation of rank $\eta$ to transform main stream hidden states into speculative stream hidden states. This initialization helps to reduce computation per forward pass, since only the main stream needs to be passed through $N-N_{s}$ layers, while speculative streams are passed through the last $N_{s}$ layers, decreasing the speculative FLOPs contribution by $(N-N_{s})/N$ and in turn helping with peak power consumption on the device. In terms of forward pass latency, FLOPs do not contribute significantly when the model is memory bound, however, as we describe in  Section 3.2.2, we sample additional tokens to make the model compute-bound, therefore FLOP reduction becomes crucial. Initialization with a hidden state of middle-upper transformer layers may also help with the future token prediction as $M^{(N-Ns)}$ itself contains high-level contextual features to aid with the prediction of future n-grams (Pal et al., ). We also experimented with value rotation based stream design which does not require identifier embeddings and incurs no parameter overhead as described in B.

#### 3.2.2 Parallel speculation and verification

In standard draft-target speculative decoding (Leviathan et al., ), speculation and verification processes happen sequentially. The draft model waits for the target model to issue a correction before generating the next draft. The target model also needs to wait for the speculative draft to be generated. Speculative Streaming makes this process more efficient by parallelizing speculation and verification. In each forward pass, the draft generated in the previous step is verified and a new draft is generated as shown in  Figure 2. For instance, in step $s$, if draft tokens $(\tilde{y_{1}}..\tilde{y_{\delta}})$ are accepted where $0<\delta\leq\gamma$, main stream $M_{\delta}$ is used to issue a correction token and logits from speculative streams $S_{\delta(1...\gamma)}$ are used to generate draft for step $s+1$.

Instead of using a linear sequence of speculated tokens for verification, we sample a tree of tokens from main and speculative streams, such that each path in the tree is one possible verification candidate. Tree drafting enables accepting the longest matching candidate sequence and more tokens can be advanced during each forward pass. To create a tree draft, instead of sampling 1 token from logits of speculative streams, $(z_{1}...z_{\gamma})$, we sample top $k$ tokens and form a tree of sampled tokens as shown in  Figure 2, such that tokens sampled from stream $n$ are predecessors of tokens sampled from stream $n+1$. We process a tree draft of speculative tokens in one forward pass by creating an additive attention mask  (Vaswani et al., ) such that each node in the tree attends to its predecessor. Attention mask between $k^{th}$ token sampled from logits of stream $j$, $\tilde{y}_{jk}$ and the $m^{th}$ token sampled from logits of stream $n$, $\tilde{y}_{nm}$ is

$$ $a_{\tilde{y}_{jk}\tilde{y}_{nm}}=\begin{cases*}0&if j = n+1,\\ -\infty&otherwise\end{cases*}$ (4) $$

Please refer to  Figure 8 for more details. It’s worth noting that for a fixed $\gamma$ and $k$, the attention mask remains constant in each forward pass and enables effective batching.

#### 3.2.3 Parallel tree pruning

One of the issues with the naive creation of a speculative tree draft is that every permutation between $k$ tokens sampled from each stream needs to be considered as a viable speculative candidate for the next verification pass. For instance, sampling $k$ tokens from each of $\gamma$ streams results in tree draft of size 1 + $\sum_{g=1}^{\gamma}k^{g}$. Furthermore, each of the draft tokens is batched with $\gamma$ speculative streams in MSA layers to ensure that the generation of the next draft happens in the same forward pass, resulting in a batch size of $(1+\gamma)*(1+\sum_{g=1}^{\gamma}k^{g})$. As batch size increases, target model inference becomes compute-bound, obviating the latency benefit of sampling more tokens. We mitigate this problem by introducing a parallel tree draft pruning layer, which prunes some of the tokens from the input tree draft based on transition probability between parent and immediate child tokens.
To obtain transition probabilities without using proxy models, we use an early-exiting-based technique. Specifically, hidden states of the main stream at layer $l$, $M^{l}$ are passed through a low-rank linear transformation $o_{\theta}$, where the rank $\theta$ is typically set to a small value like 8 to keep parameter overhead small. We use original language modeling head, $H$ to obtain early exit logits, $\tilde{z}=H(o_{\theta}(M^{l})$. $\tilde{z}_{pc}$ is used to approximate transition probability between parent token $p$ and child token $c$. The pruning layer can be inserted at any point in the network, guided by the trade-off between forward pass latency and pruning accuracy. Early insertion reduces latency but risks pruning potentially valuable tokens. Conversely, late insertion retains more ”good” tokens but comes at the cost of increased forward pass latency. In all experiments described in Section 4.1, we insert the pruning layer just before speculative stream insertion empirically. More details can be found in  Figure 7.

#### 3.2.4 Training objective

To efficiently generate future n-grams, we finetune the base model jointly on the prediction loss of the next token as well as $\gamma$ future tokens as

$$ $\displaystyle L_{ss}=$ $\displaystyle-\alpha_{0}(\sum_{t=1}^{T}\log p_{\theta}(y_{t}|y_{<t},x))$ (5) $\displaystyle-\sum_{j=1}^{\gamma}\alpha_{j}(\sum_{t=1}^{T-j}\log p_{\theta}(y_ {t+j}|y_{<t},x))$ $$

where $\alpha_{0}$ and $\alpha_{j}$ are set empirically to normalize losses of the next token and speculative tokens prediction. Tree-pruning adapter described in  Section 3.2.3 can be trained on the next token prediction loss, either jointly along with main and speculative streams or post-training of streams. Training times vary based on the number of MSA layers but are comparable to (Cai et al., ) style approach for $N_{s}=4$. For experiments described in 4, our recipe involves training LoRA adapters for 5 epochs on the downstream datasets in BFloat16, using the AdamQ optimizer, a learning rate of 5e-4, and a linear scheduler. For tree pruning (see Section 3.2.3), we use a low-rank linear transformation of rank 8 to keep parameter overhead minimal.

## 4 Experiments

**Table 1: Walltime speedup, CR ratio, parameter overhead, and Metric comparison using different models fine-tuned on downstream applications. CR ratio denotes acceleration agnostic target model call reduction ratio. We use exact match accuracy as a metric for SqlContext, and Rouge1/RougeLSum as a metric for Dialogsum and E2E-NLG tasks.**
| Dataset | Model | Method | SpeedUp ($\uparrow$) | CR Ratio ($\uparrow$) | Metric ($\uparrow$) | # Extra Parameters ($\downarrow$) |
| --- | --- | --- | --- | --- | --- | --- |
| SqlContext | OPT-1.3b | Baseline | $1.00$ | $1.00$ | $84.98$ | $-$ |
| Medusa | $2.07$ | $2.79$ | $84.98$ | $4.28E8$ |  |  |
| SS (ours) | $\mathbf{2.39}$ | $\mathbf{3.57}$ | $\mathbf{87.40}$ | $\underline{4.096E4}$ |  |  |
| PHI-1.3b | Baseline | $1.00$ | $1.00$ | $88.71$ | $-$ |  |
| Medusa | $2.58$ | $3.25$ | $88.71$ | $4.36E8$ |  |  |
| SS (ours) | $\mathbf{2.62}$ | $\mathbf{3.53}$ | $\mathbf{89.90}$ | $\underline{4.096E4}$ |  |  |
| OpenLlama-7b | Baseline | $1.00$ | $1.00$ | $89.88$ | $-$ |  |
| Medusa | $\mathbf{3.20}$ | $4.10$ | $90.11$ | $5.91E8$ |  |  |
| SS (ours) | $3.14$ | $\mathbf{4.13}$ | $\mathbf{91.70}$ | $\underline{8.19E4}$ |  |  |
| DialogSum | OPT-1.3b | Baseline | $1.00$ | $1.00$ | $43.40$/$35.56$ | $-$ |
| Medusa | $1.56$ | $1.91$ | $43.40$/$35.50$ | $4.28E8$ |  |  |
| SS (ours) | $\mathbf{1.94}$ | $\mathbf{2.62}$ | $\mathbf{44.07}$/$\mathbf{35.99}$ | $\underline{4.096E4}$ |  |  |
| PHI-1.3b | Baseline | $1.00$ | $1.00$ | $\mathbf{43.57}$/$\mathbf{35.60}$ | $-$ |  |
| Medusa | $\mathbf{1.89}$ | $2.28$ | $\mathbf{43.57}$/$\mathbf{35.60}$ | $4.36E8$ |  |  |
| SS (ours) | $1.83$ | $\mathbf{2.34}$ | $43.36$/$35.31$ | $\underline{4.096E4}$ |  |  |
| OpenLlama-7b | Baseline | $1.00$ | $1.00$ | $\mathbf{44.20}$/$\mathbf{36.50}$ | $-$ |  |
| Medusa | $1.76$ | $2.25$ | $\mathbf{44.20}$/$\mathbf{36.50}$ | $5.91E8$ |  |  |
| SS (ours) | $\mathbf{1.87}$ | $2.51$ | $43.92$/$35.70$ | $\underline{8.19E4}$ |  |  |
| E2E-NLG | OPT-1.3b | Baseline | $1.00$ | $1.00$ | $\mathbf{69.48}$/$50.17$ | $-$ |
| Medusa | $2.13$ | $2.95$ | $\mathbf{69.48}$/$50.17$ | $4.28E8$ |  |  |
| SS (ours) | $\mathbf{2.45}$ | $\mathbf{3.72}$ | $69.32$/$\mathbf{50.51}$ | $\underline{4.096E4}$ |  |  |
| PHI-1.3b | Baseline | $1.00$ | $1.00$ | $\mathbf{67.90}$/$48.50$ | $-$ |  |
| Medusa | $2.78$ | $3.35$ | $\mathbf{67.90}$/$48.50$ | $4.36E8$ |  |  |
| SS (ours) | $\mathbf{2.84}$ | $\mathbf{3.69}$ | $67.40$/$\mathbf{48.52}$ | $\underline{4.096E4}$ |  |  |
| OpenLlama-7b | Baseline | $1.00$ | $1.00$ | $\mathbf{69.50}$/$\mathbf{50.30}$ | $-$ |  |
| Medusa | $2.70$ | $3.22$ | $\mathbf{69.50}$/$\mathbf{50.30}$ | $5.91E8$ |  |  |
| SS (ours) | $\mathbf{2.96}$ | $\mathbf{3.55}$ | $68.66$/$49.56$ | $\underline{8.19E4}$ |  |  |
|  |  |  |  |  |  |  |

Table: Table 2: Walltime latency (per sample) comparison with standard draft-target based speculative decoding approach using OPT-125m as the draft model for $\gamma=4$. Although calls to target model using our approach are higher than draft-model-based speculative decoding, it does not incur auto-regressive drafting overhead, achieving better latency on OPT-1.3b and OPT-6.7b models. We use exact match accuracy as a metric for SqlContext, while Rouge1/RougeLSum is used as a metric for Dialogsum and E2E-NLG tasks.

We evaluate our methods on the pre-trained models of various scales and a diverse set of downstream applications.

Dataset. We test our methods on a diverse set of applications that are vital to on-device AI assistants, namely Structured Queries, Text Summarization, and Meaning Representation. We specifically choose fine-tuning setup since it has been a norm to share a base model and use application-specific adapters for user-facing applications. We use the Dialogsum (Chen et al., ) dataset for Text Summarization, the sql-create-context dataset built from WikiSQL (Zhong et al., ) and SPIDER (Yu et al., ) for Structured Queries, and e2e-nlg dataset (Dušek et al., ) for Meaning Representation.

Model Configuration. We tested four different open source models of various scales, Phi(1.3B)(Li et al., ), Open-llama(7B)(Touvron et al., ), and OPT(1.3B, 6.7B) (Zhang et al., ). We compare our method with the standard draft-target speculative decoding ((Leviathan et al., )) and single-model speculative decoding framework, Medusa (Cai et al., ). For the standard draft-target approach, we use OPT-125m, the smallest configuration of available open-source OPT models as the draft model.

Baselines
To compare with Medusa (Cai et al., ) style approach, we use pre-trained base models with LoRA adapters (Hu et al., ) of rank 32 and Medusa heads as the baseline, and Speculative Streaming with the same base models, stream embeddings and LoRA adapters as target. Medusa heads are trained following the recipe described in (Cai et al., ). Both Medusa heads and the number of maximum streams are fixed to 4 and the residual blocks per head used in Medusa are set to 1. For comparison with standard draft-target speculative decoding (Leviathan et al., ), we use OPT models since they come with different configurations and sizes. OPT-125m is deployed as a draft model while OPT-1.3b and OPT-6.7b are used as target models since a ratio of 10-100X is typically considered to be optimal. Note that, similar to the target model, only LoRA adapters of the draft model are fine-tuned on downstream applications because fine-tuning the entire draft model on each downstream application is not practical in on-device settings. Also, LoRA fine-tuning tends to achieve on-par performance to full-model fine-tuning (Hu et al., ).

### 4.1 Results

#### 4.1.1 Overview

We report wall-time speedups and generation quality metrics on test split using a batch size of 1 on a single Nvidia A100-80G GPU. Inference is performed in float16 using greedy sampling and $T=0$. Please refer to  Section A.2 for more experimental details and  Appendix B for ablations on top-k sampling and $T=1$. We use Exact Match (EM) accuracy metric for the structured query task and Rouge1/RougeLSum metrics for the Dialog Summarization and Meaning Representation tasks. We use $N_{s}/N$ of $1/6$ for the structured query task and $1/2$ for the summarization and meaning representation task. $N_{s}$ is chosen to ensure the generation metric is on-par with the baseline. Details on the effect of $N_{s}$ on generation metric are found in  Section 4.2.

Table 1 presents the comparison between standard auto-regressive decoding baseline, Medusa, and our approach in terms of speedup, call reduction ratios, and the number of extra parameters. We find that across a variety of downstream tasks, the walltime speedups and call reduction ratios of Speculative Streaming are consistently on-par/higher than Medusa while incurring significantly lesser parameter overhead. Furthermore, as summarized in Table 2, our approach achieves better wall-time latencies than the standard draft-target speculative decoding since the difference in the number of target calls between both approaches is not large enough to offset auto-regressive drafting overhead. All wall-time latencies are reported using open-source versions of models available on (Wolf et al., ) and it is possible that further optimizing draft and target models using efficient inference techniques (Nvidia, ) or quantization (int4/8) may lead to lower latencies. Finally, It’s worth noting that the generation metrics of our method are consistently comparable with LoRA fine-tuned base models making it an excellent alternative to next-token prediction-based fine-tuning.

#### 4.1.2 Analysis and Insights

Without Auxiliary Models Medusa heads generate each token independently from the shared hidden state of the last layer, and dependency between speculative tokens predicted by medusa heads, $y_{(t+1..t+\gamma)}$ and next token $y_{t}$ predicted by the base model at time step $t$ may not be well captured since there no attention mechanism involved. On the other hand, speculative streams attend to the main stream and each other, capturing the token dependency, resulting in better call reduction ratios than Medusa.
In terms of parameters, each Medusa head adds about $h^{2}+hv$ parameters, where $h$ is the hidden size and $v$ is the vocabulary size. The number of Medusa heads also scales linearly \wrt$\gamma$, the length of the speculative window, which in turn increases parameter overhead linearly with $\gamma$. On the other hand, Speculative Streaming uses speculative adapters which do not scale with $\gamma$. Although, Stream identifier embeddings scale with $\gamma$, the parameter overhead associated with each embedding is linear to $h$. Furthermore, in fine-tuning settings “speculative adapter” parameters are shared with base model adapters, therefore, parameter overhead associated with our approach is just $\gamma h$.

Figure: Figure 3: Speculative Streaming speeds up decoding by increasing arithmetic intensity of memory bound auto-regressive decoding step. Kernel and memory utilization of OPT-1.3b model with Medusa-style approach and draft model (OPT-125m) based speculative decoding approach is also shown for comparison.
Refer to caption: x3.png

With Auxiliary Models Speculative Streaming consistently achieves lower wall time latency than standard draft-target speculative decoding as depicted in Table 2. It’s worth noting that, target model calls of draft-target speculative decoding are lower than Speculative Streaming, however, it comes at the cost of auto-regressively running draft model $\gamma$ times to generate speculative draft. On the other hand, draft generation with Speculative Streaming incurs almost no additional latency overhead, as target model decoding tends to be memory-bound even with increased tree draft size. This translates to increased kernel utilization and arithmetic intensity as shown in Figure 3. Draft-based approach on the other hand has low kernel utilization because of the memory-bound nature of auto-regressive drafting.

An argument could be made that a smaller draft model may perform better since drafting should cost less, but acceptance rates may drop as well as the draft model size is decreased. To formalize the comparison with standard draft-target speculative decoding, we do the following analysis, let’s say, $C_{draft}$ is the latency cost associated with forward pass through the draft model, $C_{target}$ is the cost associated with forward pass through target model, while $C_{ss}$ is cost associated with speculative streaming forward pass. $\zeta$ is the number of decoding tokens advanced during the verification step for the draft-target approach while $\beta$ is the number of tokens advanced in Speculative Streaming. We equate latency cost associated with single token advancement to compare both approaches.

$$ $\displaystyle(\gamma*C_{draft}+C_{target})/\zeta=C_{ss}/\beta$ (6) $\displaystyle(\gamma+$ $\displaystyle C_{target}/C_{draft})/\zeta=(C_{ss}/C_{draft})/\beta$ $$

Figure: Figure 4: Speculative Streaming speedup over draft-based speculative decoding for different $\zeta/\beta$ and target/draft latency ratios, where $\zeta$ denotes the number of advancements per verification step for draft-based speculative decoding while $\beta$ denotes the same for Speculative Streaming.
Refer to caption: x4.png

Assuming $\gamma=4,C_{target}/C_{draft}=10$, and $C_{ss}\approx C_{target}$, $\zeta=1.4\beta$, meaning that advancements per verification step in standard draft-target approach have to be 1.4X of Speculative Streaming to achieve wall time latency parity. Note that, this analysis ignores cache adjustment overhead and prompt processing overhead, but provides valuable intuition to guide the choice between draft-target vs Speculative Streaming approaches. We also analyze under which settings speculative streaming is likely to offer more benefits as compared to the standard draft-target approach. Fig. 4 shows theoretical speedups of Speculative Streaming over draft-target based approach for different Target to draft latency ratios. As the latency ratio increases, the draft-target approach is likely to offer more speedup benefits when $\zeta/\beta>1$, meaning that when the draft model is accurate enough to achieve more token advancements per target model verification step than Speculative Streaming and also small enough to yield higher latency ratios, it is likely to benefit more. Finding/creating such a model usually requires significant engineering efforts. In downstream application settings, finding ideal draft models becomes even more challenging since $\zeta$ tends to vary based on application. If applications share the draft model and only train adapters, the draft model may not remain small enough to meet target-to-draft latency ratios, making it challenging to achieve more speedups than Speculative Streaming.

Figure: Figure 5: As more tokens ($k$) are sampled from each stream keeping $\gamma$ fixed for the creation of a tree draft, walltime speedup increases due to the increased number of candidates. This trend reverses as $k$ continues to increase and the model transits into the compute-bound phase. Pruning less probable paths from tree draft helps to reduce compute for higher values of $k$ thereby reducing latency per forward pass and offering more speedup.
Refer to caption: x5.png

### 4.2 Ablations

Speculative Draft Size.
To improve the acceptance rate of the tree draft, we try various settings of $\gamma$, the number of speculative positions, and $k$, the number of sampled tokens per speculative position. Figure 5 shows walltime speedup for $\gamma=3$. As we sample more tokens from each speculative position, advancement per forward pass, $\beta$ increases since more candidates are available for verification, leading to more speedup. However, as we continue to increase $k$, forward pass latency overhead becomes more prevalent as the model transitions into compute-bound phase and the speedup reverses the course. This is because naively forming a tree draft leads to an exponential increase in batch size with $k$ as described in 3.2.3. We insert a tree pruning layer to remove less probable paths and reduce the size of the tree draft. Pruning tree draft reduces forward pass latency, and a well calibrated threshold ensures that only noisy paths in the tree get pruned. Tree pruning tends to help with walltime speedup as $k$ continues to increase as shown in Figure 5.

Number of MSA Layers
There are trade-offs involved in deciding the number of MSA layers to incorporate in terms of downstream generation metric, training time, and FLOPs increase. As we increase the number of MSA layers, the generation metric improves and this trend remains the same across different downstream tasks.
Typically incorporating MSA in the top 2 - 8 layers offers a good trade-off between metric, FLOPs increase and training time. Figure 6 shows the generation performance of the OPT-1.3b model on Structured Query and Summarization tasks.

Figure: Figure 6: As the number of multi-stream attention layers increases, metrics on downstream tasks improve as well. We use RougeLSum as the metric for the Dialogsum task, and Exact Match (EM) accuracy as the metric for the ContextSQL task.
Refer to caption: x6.png

## 5 Conclusion

In this paper, we proposed Speculative Streaming, a method to accelerate decoding of large language models. Compared to the standard speculative decoding approaches, Speculative Streaming removes the need for an auxiliary “draft” model. Instead, it unifies speculation and verification by efficiently fusing multiple speculative streams into a single “target” model. Speculative Streaming simplifies the fine-tuning process and achieves on-par or better speed-up and quality compared to previous approaches. It is also parameter efficient and removes the need for loading two models into the memory, making it a suitable approach for resource-constrained scenarios.

## Acknowledgements

We would like to thank
Sachin Mehta, Moin Nabi, Antonie Lin, Minsik Cho, Arsalan Farooq, and Jason Williams
for their valuable feedback and discussions.

## Appendix A Implementation Details

### A.1 Tree Draft Management

In this section, we go into more detail about tree draft sampling, flattening, and pruning. As shown in the main paper, when processing prompt $(x_{1}...x_{t})$, we insert speculative streams along with the last token to generate logits, $z_{t}$ corresponding to main stream and $(z_{t1}...z_{t\gamma})$ corresponding to speculative streams. Tree draft is sampled following the procedure described in  Section 3.2.2. The sampled draft is then flattened along the sequence length dimension and the attention mask is composed such that child nodes attend to their predecessors starting with root as shown in  Figure 7 and  Figure 8. The root token of the tree draft is the correction issued by main stream. Each iteration after prompt processing involves verifying the previous tree draft and sampling a new one. After passing the tree draft through $N-N_{s}$ layers, we use contextual features learned by middle layers to approximate transition probability between parent and child tokens. As shown in  Figure 7, since the transition probability between token $``parameter^{\prime\prime}$ and $``compare^{\prime\prime}$ is less than a set threshold, we prune the sub-tree starting from $``compare"$ in the feature domain , and $m_{2},m_{5},m_{6}$ are pruned. Please note that the key value cache of layers $0..(N-N_{s}-1)$ before the pruning layer is not trimmed at this point to keep pruning latency overhead minimal. Key value cache backtracking is done lazily after each generation step. Speculative streams are inserted alongside each node in the pruned draft. Layers $(N-N_{s}..N)$ use Multi-stream attention as described in  Equation 2. The verification procedure finds the longest matching path in the pruned tree that main stream can accept. As shown in  Figure 7, path $(``parameter^{\prime\prime},``efficient^{\prime\prime},``speculative^{\prime
\prime})$ is accepted. Correction token sampled from logits of main stream corresponding to last accepted token, $m_{1}$ becomes new root while tokens sampled from logits of streams $(s_{10},s_{11})$ form the sub-tree.

Figure: Figure 7: Parallel tree draft speculation and verification: Tree draft from the previous iteration is flattened for verification. After $N-N_{s}$ MHA layers, the tree pruning procedure obviates less probable tokens based on transition probability between parent and child tokens. In this illustration $Z_{i}$ denotes normalized early exit logits corresponding to main stream at index $i$, $m_{i}$, while $Z_{ij}$ denotes transition probability between token at index $i$ and $j$ in flattened tree draft. The verification procedure is subsequently run on the pruned tree and speculative tokens are sampled from streams corresponding to the latest accepted token. In above illustration, $``speculative^{\prime\prime}$, $``fine,decoding^{\prime\prime}$ and $``looking,tuning^{\prime\prime}$ are sampled from streams $m_{1}$, $s_{10}$ and $s_{11}$.
Refer to caption: x7.png

### A.2 Experimental Setup Details

Fine-tuning procedure for both baseline and target approaches described in the paper in  Section 4 involves training LoRa adapters for 5 epochs. We set $\alpha_{0}=1$ and $\alpha_{j}=0.1$ for $j=1...\gamma$ to weigh speculative loss relative to next token prediction loss for both baseline and target methods. We experimented with linear transformations of different ranks to initialize speculative streams from main stream as described in  Equation 3, however we find that simply using identity transformation achieves similar performance with much less parameter overhead. We use identity transformation for all the experiments described in Section 4.
We report best results for Medusa and our approach over different $\gamma$ and $k$ values, while for standard draft-target speculative decoding approach $k$ is fixed to 1. We also report accelerator agnostic speedups (call reduction ratios) assuming negligible verification and draft composition overhead as latency of forward pass, verification and draft composition procedures vary greatly depending on accelerator (\ega mobile device neural engine \vsNvidia A100), while call reduction ratio metric tends to serve as roof-line for achievable speedup. Lastly, we use “hard“ matching criteria for verification of speculative draft. Relaxing this criteria to “soft“ matching may yield higher speedups (Cai et al., )

Figure: Figure 8: Attention mask for tree draft is composed in such a way that child tokens can attend to all predecessors starting from root, root being correction issued by main stream. In this illustration, $``early``$ attends to $``parameter``$ and $``efficient``$ and itself since $``parameter-efficient-early``$ forms one path in tree. $``early``$ is also replicated to form another path $``parameter-compare-early``$. This attention mask allows batching multiple paths and increasing acceptance rate as number of candidates increase.
Refer to caption: x8.png

Figure: Figure 9: (a) We analyze the effect of value projection rotation on RougeLSum scores of the Dialog summarization task using PHI-1.3b as the base model for different numbers of MSA layers. Each stream is rotated in proportion to the distance from the main stream. (b) We study the effect of top-k sampling on wall-time speedups and call reduction ratios for Speculative Streaming (SS) and Medusa style approaches using OPT-1.3b as a base model on the Meaning Representation task.
Refer to caption: x9.png

## Appendix B Ablation:

Value Rotation
We analyzed more ways of differing computation of main stream from speculative streams. Apart from using dedicated stream embeddings, one way to differentiate the computation while incorporating a sense of relative position is simply rotating streams relative to each other. In this ablation, we initialize each stream with the main stream hidden state and rotate the value projection during attention computation in the proportion of the relative distance from main stream as :

$$ $V^{k}_{tn}=V^{k}_{t}e^{i\epsilon n}$ (7) $$

Where $1<=n<=\gamma$ is stream index, $V^{k}_{t}$ denotes value projection of main stream at time step $t$ and layer $k$, while $V^{k}_{tn}$ denotes value projection of stream n, $0\leq\epsilon\leq\frac{\pi}{2N}$ denotes an arbitrary rotation step and $N$ denotes the sum of maximum sequence length and number of streams. Figure 9 (a) shows the effect of using value rotation on Rouge scores on the Dialog Summarization task with the Phi-1.3b model. Downstream metric for value rotation-based approach tends to be lower than using dedicated stream embeddings across different settings of MSA layers, however, the trend of increasing metric with added MSA layers remains the same. It’s worth noting that for $N_{s}=16$, simply rotating value projections achieve better metrics than using $N_{s}=4$ with dedicated stream embeddings.

Top-k Sampling
In the main paper, we reported speedup results using greedy sampling and T=0. To further analyze speedups in the Top-k sampling regime, we try various values of $k$ and T = 1 for both Medusa style and Speculative Streaming approaches. Figure 9 (b) shows the effect of increasing $k$ on the walltime speedups and call reduction ratios. Although increasing $k$ leads to lower wall-time speedups for both baseline and target methods due to stochastic rejection of tokens, our approach retains its lead achieving better call reduction ratios and walltime speedups across different values of $k$.

## Appendix C Compute and Memory Profiling

The draft overhead associated with the standard draft-target speculative decoding approach tends to be non-trivial especially when the latency ratio between target and draft models $c_{target}/c_{draft}<=10$. This is because speculation and verification procedures are run in serial manner. Figure 10 shows the kernel utilization timeline when OPT-125m is used as a draft while OPT-1.3b model is used as the target. Auto-regressive draft generation decreases overall kernel utilization in draft-target approach, while additional computation involved in MSA layers increase kernel utilization in case of Speculative Streaming thereby efficiently utilizing the accelerator and speeding up the decoding process. Negligible cost draft models may offer a better choice to keep kernel utilization at higher levels in case of draft-target approach, however, acceptance rates tend to drop as draft model size decreases.

## Appendix D Qualitative Examples

In this section, we present qualitative examples to illustrate the effectiveness of Speculative Streaming. By examining specific instances, we aim to highlight how this approach enhances the overall performance of the decoding process. An example of the SQL query generation task is shown in Figure 11, while a dialog summarization example is shown in Figure 12. Each row indicates the previous sequence of accepted draft tokens (in black) and the new sequence of generated tokens in green/red. We use $\gamma=4$ and $k=1$ to illustrate the decoding process. Green tokens in each row indicate tokens accepted in the next forward pass, while red tokens indicate tokens rejected in the next forward pass. Speculative Streaming appears to generate meaningful drafts with high acceptance rates by capturing dependencies between tokens quite effectively, despite generating them in a non-auto-regressive manner.

Figure: Figure 10: Kernel utilization timeline for speculative streaming and the standard draft-target speculative decoding. Draft-target approach runs speculation and verification in serial manner while it is parallelized in Speculative Streaming. Auto-regressive draft generation often has low kernel utilization as shown leading to decreased overall kernel utilization while MSA layers in Speculative Streaming increase kernel utilization by generating a non-autoregressive draft and speeding up decoding significantly.
Refer to caption: x10.png

Figure: Figure 11: Speculative streaming on SQL generation task for $\gamma=4$ and $k=1$, each pass verifies the previous draft and generates a maximum of 5 tokens. For instance in pass 4, $``credit"$ and $``_"$ (shown in red) are rejected and $``hour",``_{_}",``fall",``_",``_"$ are speculated.
Refer to caption: x11.png

Figure: Figure 12: Speculative streaming on Dialog Summarization task for $\gamma=4$ and $k=1$, each pass verifies the previous draft and generates a maximum of 5 tokens. For instance, in pass 3, $``is",``a",``character"$ are rejected and $``was",``a",``character",``and",``he"$ are speculated.
Refer to caption: x12.png

## Peer Reviews

confidence: 4
contribution: 2
initial_rating: 5
presentation: 3
questions: see cons
soundness: 2
strengths: This paper is generally well-written and easy to follow.

The experiments of this paper are detailed and the authors test different llms, which is good.
summary: This paper proposes a non-autoregressive draft embedding to accelerate speculative decoding.
weaknesses: 1) The method of this paper is very similar to BiTA, https://arxiv.org/html/2401.12522v2.

2) Due to the params of LLM are also updated, I just wondering if the training dataset will introduce bias. For example, if the training set is SQL, the metric of speculative streaming may be very good but fails at other tasks, e.g., machine translation. Can the authors add lossless acceleration result like eagle?

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: 1. In Figure 3 and Figure 4, do you achieve a 3-time speedup in comparison to 2-model SD?
2. What prompts are used during the evaluations?
3. Are the target model weights frozen in all experiments? Why do you choose to “fine-tuning only LoRA parameters of MSA layers”?
4. You mentioned “Furthermore, it is important to highlight that the generation quality of Speculative Streaming consistently outperforms that of next-token prediction-based finetuning, positioning it as a compelling alternative to LoRA-based fine-tuning approaches.” in line 405.” What is the evidence of this?
soundness: 3
strengths: **Parameter Efficiency**: The proposed multi-stream attention method effectively reduces the parameter requirements for speculative decoding.


**GPU Utilization**: By design, the multi-stream attention architecture achieves higher GPU kernel utilization, providing a notable advantage over popular methods like Medusa.


**Evaluation Result**: Speculative streaming requires significantly fewer parameters than other speculative decoding approaches, enhancing both efficiency and practicality.
summary: This paper presents speculative streaming, a parameter-efficient method for speculative decoding. Speculative streaming leverages multi-stream attention to integrate representations of future token predictions directly into the language modeling process. Unlike traditional approaches, it uses a multi-token prediction strategy during training rather than the standard next-token prediction. In evaluations, the proposed method demonstrated superior performance in both latency and generation quality compared to several baseline methods.
weaknesses: **Model Evaluation**: Since the proposed training method modifies the original model output, a thorough evaluation is essential to verify the claimed integrity of the target model. While model performance is reported on the SqlContext, Dialogsum, and e2e-nlg datasets using metrics like exact match and ROUGE score, these evaluations may not fully capture the performance of a modern LLM, such as LLaMA.

**Formatting Issues**: The citation format does not meet ICLR requirements, and Figure 17 appears distorted. The titles in the headers are not rendered.


**Lack of Throughput Experiments**: The experiment is conducted on an Nvidia A100 GPU with a batch size of 1, and an ablation study with batch sizes of 2 and 4 is included in the appendix. However, using an A100 for inference with a batch size of 1 is uncommon in practice. An evaluation of throughput (at maximum batch size) compared to other methods is necessary to demonstrate the practical performance of speculative streaming.


**Lack of Motivation**: The paper emphasizes parameter efficiency in the speculative process, though a draft model may contain as little as 1% of the parameters of the target model. The significance of this efficiency focus is not shown and would benefit from further justification.

---

confidence: 4
contribution: 3
initial_rating: 8
presentation: 3
questions: 1. How does Speculative Streaming perform on very long sequences (e.g., 10,000+ tokens)? Does the efficiency gain remain consistent?
2. Can you provide more insights into how the multi-stream attention mechanism affects the model's understanding of context and coherence in generated text?
3. How sensitive is the method to hyperparameters, particularly the number of speculative streams? Is there an optimal range for different model sizes or tasks?
soundness: 4
strengths: 1. The novelty is good. This paper presents an innovative approach to speculative decoding that eliminates the need for auxiliary draft models, addressing a significant limitation in existing methods.
2. The method is efficient. Speculative Streaming demonstrates impressive speedups (1.9-3X) while using substantially fewer parameters than competing approaches, making it highly efficient and suitable for resource-constrained environments. The speedup is consistent  across diverse tasks, including summarization, structured queries, and meaning representation, indicating its broad applicability.
3. The method works well for both fine-tuned and no-loss settings, so it useful for many applications, from specific tasks to general chatbots.
summary: This paper introduces Speculative Streaming, a novel approach to make LLM inference faster without needing extra models. It combine speculation and checking in one model with multi-stream attention and put future token planning in fine-tuning. Speculative Streaming make inference 1.9-3X faster for different tasks, make generation better, and use ~10000X less extra parameters than other methods. It good for devices with not much resource and can be used for chatbots without losing quality.
weaknesses: The method was tested only on model with a size < 7B parameters, a more detailed analysis of how it scales with very large models (e.g., 100B+ parameters) would be valuable. And a more in-depth theoretical analysis of why Speculative Streaming works would be helpful, particularly in terms of the interplay between multi-stream attention and future token planning.

---

confidence: 4
contribution: 2
initial_rating: 3
presentation: 2
questions: Most of my primary concerns are outlined in the weaknesses section above. Here are additional minor concerns:

- In line 107, the phrase "Moreover, using a dedicated layer leads to significant parameter overhead" is somewhat misleading. Compared to Medusa, which incorporates multiple MLP heads, Eagle requires only one autoregressive head, thereby **reducing parameter overhead**, as shown in Table 1.
- The authors investigate a tree drafting strategy in Section 3.1.1 and Appendix A.1. Compared to Medusa’s fixed tree structure of 64 candidate tokens, SS increases the number of candidates to a batch size of $(1+\gamma) \cdot \left(1+\sum_{g=1}^\gamma k^g\right)$ (where $\gamma=3$ and $k=3$), while limiting exploration breadth and depth to 3. Have the authors compared this tree implementation with that of Medusa?
- In line 321, the authors mention that "For generic chatbot-like settings, where fine-tuning is not required, we train speculative streams while keeping the base model frozen as noted in Section 3.1.4." The specific settings for this configuration should be clarified: is LoRA tuning still applied, or are only the stream embeddings tuned?
- Please provide a more detailed explanation of the CR (call reduction) ratio metric. Does it correspond to the mean number of generated tokens per step?
- The reporting of extra parameters in Table 1 appears imprecise, as Medusa-2 requires tuning of the original LLM. Comparisons should focus on the number of tuned parameters rather than extra parameters.
- In line 403, the authors claim that "the generation quality of Speculative Streaming consistently outperforms that of next-token prediction-based fine-tuning, positioning it as a compelling alternative to LoRA-based fine-tuning approaches." However, no comparison with next-token prediction-based fine-tuning methods (such as LoRA tuning) is provided, which makes this an overstatement.
soundness: 3
strengths: 1. The paper presents a novel investigation to speculative decoding by modifying the attention mechanism. Compared to prior methods like Medusa and Eagle, the authors claim that Speculative Streaming requires fewer parameters while achieving superior speedup performance.
2. This work provides an insightful explanation for Speculative Streaming’s effectiveness, which is illustrated in Section 4.1.2. The findings suggest that by enabling LLMs to attend to future tokens, the attention mechanism would enhance its ability to anticipate and plan for the nearest next token, thus improving generation quality. This result holds promise for future research directions.
3. The authors provide extensive experimental details and analysis in the Appendix, covering aspects like the tree drafting process, training costs, parameter overhead, and etc. These additions effectively address some of my initial concerns.
summary: This paper introduces Speculative Streaming, a method that integrates multiple soft embeddings before the $N-N_s$ multi-head attention layers of target LLMs and fine-tunes LLMs using LoRA, enabling the parallel prediction of these additional positions. Compared with prior methods like Medusa which modifies the MLP layers, Speculative Streaming focuses on modifications of LLM attention, providing a unique and investigative perspective on speculative decoding. The approach’s efficacy is validated through evaluations across various tasks and LLMs, achieving a 1.9 to 3x overall speedup.
weaknesses: 1. **The original LLM distribution is altered**. Unlike most speculative decoding such as [1], Medusa-1[2], and Eagle[3] that maintains the original output distribution of target LLMs, Speculative streaming (SS) modifies the target LLM's attention, enabling the main stream to attend to speculative streams and thus altering the original output distribution. This modification would largely impact the application of this paradigm since the generation quality may not be guaranteed. Although comparative performance is shown in Tables 1 and 2, SS performance is likely sensitive to fine-tuning procedures and evaluation domains.
2. **Lack of Experimental Detail**. In the abstract and results of Section 4.1.1, the authors claim that in **lossless** settings for generic chatbot applications that **do not necessitate supervised fine-tuning**, SS could achieve 2.9 - 3.2X speedup while maintaining the integrity of the base model’s output. However, I found no detailed description of the experimental setup for this configuration. Given that SS introduces stream embeddings and LoRA tuning, clarification on how SS accomplishes lossless speedup without fine-tuning is necessary. Detailed settings should be provided. Besides, could SS maintain the same output distribution as the original LLM?
3. **Some demonstrations are confusing**. In Section 3.1.4 (Training) and Appendix D, the authors mention using LoRA to train the model with the objective in Equation (5). However, LoRA-tuned parameters are not highlighted in Figure 2, which suggests that only stream embeddings are tuned. A clear discussion is needed on which parameters are subject to LoRA tuning—does LoRA tuning apply to all multi-stream attention (MSA) layers?
4. **Computation overhead of SS**. In Table 1, SS is shown to require fewer parameters than Eagle and Medusa. However, SS appears to incur higher computation overhead in drafting than Medusa, as the extra stream representations require forward passes through the last $N_s$ MSA layers, including both the MLP and attention layers. This adds an additional computational burden to the whole framework.
5. **Clarification of Multi-Stream Attention**. The term "multi-stream attention" may be somewhat misleading. SS resembles a combination of soft-prompting (via stream embeddings) and LoRA tuning, with the drafting process involving not only MSA layers but also the MLP layers in the last $N_s$ layers. Consideration of alternative wording might improve clarity.

[1] Fast Inference from Transformers via Speculative Decoding. Leviathan et.al. ICML 2023.

[2] Medusa: Simple LLM Inference Acceleration Framework with Multiple Decoding Heads. Can et.al. ICML 2024.

[3] EAGLE: Speculative Sampling Requires Rethinking Feature Uncertainty. Li et.al. ICML 2024.

Meta-review: This paper introduces Speculative Streaming as an attempt to unify speculation and verification in a speculative decoding setting, all in the same base model, without the need for an external auxiliary draft model. The proposal leverages what authors refer to as multi-stream attention, which is added to the base model, and enables that model to generate drafts beyond the next token. In doing so, forward passes can simultaneously be used to verify tokens generated so far, and speculate future tokens.

The main strength of this manuscript is how simple and potentially efficient the proposal is, with evaluations on different base models showing performances that match or improve upon recent methods such as Medusa, Hydra, and Eagle.

On the other hand, the presentation is not clear enough. The method description is a bit convoluted and contains more motivation than actual description of the method. The manuscript lacks a pseudo-code or something else that simply defines the inference procedure. Fine-tuning is also unclear and it's difficult to get from the manuscript what needs training.

The experiments are also such that it's non-trivial to draw conclusions from them. The sets of baselines change from evaluation to evaluation, without a clear justification. For example, for wall-clock time speedup comparisons, baselines in Figures 3 and 4 (and Figures 5 and 6) change. Details on fine-tuning are also missing. That is, do authors fine-tune on a composition of datasets or they fine-tune for each target task independently? Moreover, it's also unclear to what extent the evaluation is confounded by the implementations of baselines. The baseline results reported throughout the paper seem to correspond to the authors own implementations of these baselines. Ideally, we would additionally be able to compare the proposal's results against baseline performances obtained independently. Finally, authors center  the claims of improved efficiency on parameter efficiency, but gains in terms of FLOPs are not very pronounced. I would perhaps suggest a comparison in terms of inference throughput in tokens/s alongside memory footprint and task performance.

All in all, this paper requires improvements prior to publication for overall clarity and readability, but also for stronger evidence of the benefits of the proposal, which are a bit unclear in the current form.

Decision: Reject