jakeatx/mode-biased-MTP

Mode-biased MTP: paired accuracy and speed results

This dataset holds the paired results behind mode-biased multi-token prediction (mb-MTP): a way to run MTP speculative decoding that finishes answers sooner. In our paired tests, mb-MTP cut total time per answer by about 10% overall (time ratio 0.902, 95% CI 0.865-0.939) and raised generation throughput. The accuracy differences we measured are not statistically distinguishable from zero.

Headline results

• Faster to finish. Total time per answer fell on both benchmarks, and both confidence intervals exclude 1.0: 0.904 on LiveCodeBench v6 and 0.857 on GPQA Diamond.
• Higher throughput. Generation speed rose from 55.0 to 66.8 tokens/s on LiveCodeBench (+21%) and from 98.3 to 108.7 tokens/s on GPQA Diamond (+11%).
• Accuracy. No accuracy difference reaches significance at p<=0.05 (all p-values are two-tailed). Each 95% confidence interval includes zero.

What it is

Multi-token prediction (MTP) speculative decoding. A small draft head proposes several next tokens at once. The main model then checks all of them in a single pass. Normal ("exact") acceptance keeps a drafted token only in a way that reproduces the main model's sampling distribution exactly.

Mode-biased MTP. Mode-biased acceptance relaxes that rule toward the main model's most-preferred tokens. Drafted tokens that agree with the model's high-probability choices are accepted more often. That lets the drafter run deeper (depth 6 here), so more tokens are accepted per verification step and answers finish sooner.

Why KL numbers are not comparable. The bias moves probability toward the model's own preferred (modal) answers, so it is mode-seeking rather than random noise. We measured a KL divergence of about 0.009 against the exact distribution on generated text at depth 6. That number should not be compared with KL from quantization or other lossy changes. Those can push probability in arbitrary directions, including toward answers the model does not prefer. Mode-biased acceptance sharpens the model toward what it already favors.

Availability. mb-MTP ships in the llamAmpere llama.cpp fork and is on by default for MTP. To opt out, pass --no-spec-mb-mtp. The opt-in form is --spec-mb-mtp, and the environment variable is LLAMA_ARG_SPEC_MB_MTP.

Setup

• Model: the public Swift 1.5 (Qwen3.8 27B) IQ4_XS-M GGUF.
• Sampling: temperature 1.0, top-k 20, top-p 0.95, min-p 0, reasoning effort medium.
• Arms: exact MTP at adaptive depth 3/4 (the normal default) versus mode-biased MTP at fixed depth 6.
• Pairing: each pair is the same question, same seed, same RNG seed, and same GPU box, run back to back with the order alternated.
• Hardware: a single RTX 3090-class GPU.
• LiveCodeBench release v6: a 100-task subset (29 easy, 33 medium, 38 hard) with 15 seeds, giving 1,500 pairs. Each answer is graded with all public and hidden tests in isolated Docker containers.
• GPQA Diamond: all 198 questions with 2 seeds, giving 396 pairs.
• Statistics: paired differences, with bootstrap resampling clustered by question (10,000 draws). All p-values are two-tailed.

Results

Wall-clock time to finish an answer

Ratio of total time, mb-MTP over exact (lower is faster). In every row the 95% CI excludes 1.0.

Benchmark	Time ratio (95% CI)	Reading
LiveCodeBench v6	0.904 (0.867-0.942)	about 9.6% less time per answer
GPQA Diamond	0.857 (0.791-0.924)	about 14.3% less time per answer
Pooled	0.902 (0.865-0.939)	about 9.8% less time per answer

Throughput and answer length

Benchmark	Generation throughput (exact to mb-MTP)	Mean answer length in tokens (exact to mb-MTP)
LiveCodeBench v6	55.0 to 66.8 tokens/s (+21%)	12,698 to 13,926
GPQA Diamond	98.3 to 108.7 tokens/s (+11%)	4,062 to 3,848

On LiveCodeBench, mb-MTP answers ran about 10% longer yet still finished sooner. A separate, earlier speed study on the same model measured a 5.3% faster time-to-complete for depth-6 mb-MTP (two-tailed p = 0.0019).

Accuracy

Benchmark	Pairs	Exact MTP	mb-MTP	Difference	95% CI	Two-tailed p
LiveCodeBench v6	1,500	88.20%	87.13%	-1.07 pts	-2.27 to +0.13	0.085
GPQA Diamond	396	81.06%	82.83%	+1.77 pts	-1.26 to +4.80	0.27
Pooled	1,896 (298 questions)	-	-	-0.47 pts	-1.60 to +0.65	0.45

None of the accuracy differences is statistically significant at p<=0.05 (two-tailed), and every 95% confidence interval includes zero. The pooled estimate across 298 questions is -0.47 points. In these tests, mb-MTP's speedup came with no statistically detectable change in accuracy. More seeds or questions would narrow the intervals further.

Why this matters

• Faster answers on consumer GPUs. Time to finish an answer dropped by roughly 10-14% in these paired tests, with higher generation throughput.
• A mode-seeking bias. Acceptance leans toward the model's own preferred answers instead of adding random noise.
• Deeper drafting pays off. Looser acceptance lets the drafter run at depth 6 and turn the extra proposed tokens into real speedups.

Files

data/paired_results.csv has one row per question, seed, and arm.

Column	Description
benchmark	Benchmark name (LiveCodeBench v6 or GPQA Diamond)
question	Question or task identifier
seed	Seed index; both arms of a pair share it
arm	exact_mtp_adaptive_d3_4 or mode_biased_mtp_d6
correct	1 if the answer was graded correct, otherwise 0
finish_reason	Why generation ended (for example stop or length)
completion_tokens	Number of generated tokens
wall_seconds	Prompt plus generation time, as reported by the server

Raw model responses and internal measurement tooling are not included.

How to reproduce the summary

import pandas as pd

df = pd.read_csv("data/paired_results.csv")

# Per-arm accuracy by benchmark
print(df.groupby(["benchmark", "arm"])["correct"].mean().unstack() * 100)

# Time ratio (mb-MTP total time / exact total time) by benchmark and pooled
tot = df.groupby(["benchmark", "arm"])["wall_seconds"].sum().unstack()
ratio = tot["mode_biased_mtp_d6"] / tot["exact_mtp_adaptive_d3_4"]
print(ratio)

pooled = df.groupby("arm")["wall_seconds"].sum()
print(pooled["mode_biased_mtp_d6"] / pooled["exact_mtp_adaptive_d3_4"])

The confidence intervals in the tables come from bootstrap resampling clustered by question (10,000 draws), which is not included in the snippet above.

Limitations

• One model (Swift 1.5, Qwen3.8 27B) and one quantization (IQ4_XS-M).
• Single-GPU class (RTX 3090-class); other hardware may behave differently.
• The accuracy tests are not powered to rule out small differences. The LiveCodeBench point estimate is -1.07 pts (two-tailed p = 0.085, 95% CI -2.27 to +0.13), which is not statistically distinguishable from zero.
• Seed counts are modest: 15 seeds for LiveCodeBench and 2 for GPQA Diamond, so the GPQA interval is wide.
• More LiveCodeBench answers hit the length cap with mb-MTP than with exact MTP: 36 versus 21 of 1,500 each. All GPQA Diamond answers finished normally in both arms.