File size: 11,069 Bytes
dcc3a31 b80a86d dcc3a31 f0048ae dcc3a31 2c8287a f0048ae 2c8287a f0048ae 2c8287a dcc3a31 df5757e dcc3a31 b80a86d dcc3a31 b80a86d dcc3a31 b80a86d dcc3a31 f0048ae b80a86d dcc3a31 b80a86d dcc3a31 b80a86d f0048ae dcc3a31 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 | ---
license: apache-2.0
language:
- en
tags:
- speculative-decoding
- draft-model
- qwen
- vllm
pretty_name: EMC draft model - code, logs and results
---
# EMC — a draft model for the Speculative Decoding Championship
Work for the **Speculative Decoding Championship** of the emc2 workshop at AAAI 2027:
build the best draft model for a fixed target (**Qwen3.8-27B**, bf16, 16K context) served by an
unmodified **vLLM v0.31.0**, with `K = 3` draft tokens per round.
```
score = 100 × ( 0.50·(τ−1)/(τ_B−1) + 0.25·min(1.5, M_B/M) + 0.25·min(1.5, TPOT_B/TPOT) )
```
τ is the acceptance length, M the draft memory (stored weight bytes + draft KV cache at 16K
tokens), TPOT the median time per output token; `B` is the baseline, the target's built-in
MTP head (τ_B = 2.802, M_B = 0.917 GB, score 100). A draft is ranked only if τ ≥ 0.9·τ_B.
**Hardware.** Everything here — data generation, training and every evaluation — runs on a
single **NVIDIA RTX PRO 6000 Blackwell (96 GB VRAM)**.
## The draft
A **replacement MTP head in the baseline layout** (`method: mtp`): the same 15 `mtp.*`
tensors as the target's built-in head, the target's `config.json` unchanged, no code.
| | baseline head | this draft |
|---|---|---|
| layout | `mtp.*`, 424.7 M params | identical |
| weights | as shipped with the target | fine-tuned for 3-step recursive drafting on the target's own outputs |
| storage | bf16, 0.849 GB | large matrices in FP8 (E4M3), rest bf16: **0.540 GB** (a plain bf16 variant is exported too) |
| memory metric (weights + KV) | 0.917 GB | **0.607 GB** → M_B/M = 1.51, i.e. the 1.5 cap |
### Why this design
Three things were read out of the engine source (`qwen3_5_mtp.py`, `llm_base_proposer.py`)
before choosing it:
1. **The head's shape is fixed by the target.** vLLM builds the MTP module from the *target's*
config, not the submission's, so an `mtp` submission cannot be narrower or shallower. A
replacement head is therefore a question of *better weights*, and of how they are stored.
2. **Drafting is recursive.** Step 1 sees the target's final hidden state; steps 2 and 3 feed the
head its *own* previous output (and write their own keys/values into the draft KV cache).
A head trained only for one-step prediction is off-distribution for two thirds of what it
is asked to do.
3. **The LM head and embeddings are shared with the target**, so they cost nothing in the memory
metric, and the per-round draft cost is dominated by the three LM-head evaluations — the
head's own size barely moves TPOT. Higher acceptance is what moves it.
### Training
* **Data — the target's own greedy answers.** Fresh prompts in the four evaluated domains
(chat, code, math, long-form writing), phrased like the public dev tasks, are answered
greedily by the target running in the serving engine itself (vLLM 0.31.0), so the training
text is exactly the kind of text the draft has to predict. The target's final hidden state
at every position is then recomputed with the reference implementation in one
teacher-forced pass. Two checks guard this step: the reference implementation must agree
with the engine's greedy choices along the dev references, and the offline simulator
(below) must reproduce the kit-measured acceptance of the baseline head. Prompts come from
public instruction sets (GSM8K / Orca-Math, WritingPrompts, UltraChat / Alpaca / Dolly,
Python instruction sets, MBPP); anything overlapping the dev prompts is removed and the
dev set is never trained on.
* **Objective — the engine's drafting loop.** `emcdraft.head.unroll` runs all three draft steps
for every position of a sequence in parallel, with exactly the key/value visibility the
engine's draft cache has (verified prefix, then the round's own entries). Each step is
trained on the token the target really emitted and also distils the target's full
distribution for that token; later steps are weighted by whether the earlier ones were
right, because the engine only reaches them in that case.
* **FP8 with QAT.** An exact, function-preserving re-scaling (`equalize_`) first moves the big
matrices into the range where E4M3 has relative precision; they are then trained through
E4M3 rounding with a straight-through estimator, so the compact file is the model that was
optimised. The stock engine up-casts FP8 tensors to bf16 at load time — the saving is in
stored bytes, which is what the competition's memory metric counts (`emc2/submission.py`);
runtime GPU memory of the head is unchanged. Both variants are exported and reported.
* **Offline simulator.** `emcdraft.sim.simulate` replays greedy speculative decoding from stored
hidden states and returns τ without starting a server. It is checked against the kit's
measured baseline acceptance before any training, and used for checkpoint selection on a
held-out slice of the *training* data (the dev set is only reported, never selected on).
## Results
Official kit `eval` (vLLM 0.31.0, all 160 dev prompts, K = 3), run **r2**, every row measured
in the same run on the same **NVIDIA RTX PRO 6000 Blackwell**:
| draft | τ | chat / code / math / long-form | TPOT | memory | score, same GPU | score, published baseline |
|---|---|---|---|---|---|---|
| baseline (the target's built-in MTP head) | 2.805 | 3.07 / 3.77 / 3.63 / 2.36 | 15.39 ms | 0.917 GB | 100.0 | 96.2 |
| **this draft, FP8 (submitted variant)** | **2.900** | 3.08 / 3.77 / 3.70 / 2.50 | 15.24 ms | **0.607 GB** | **115.4** | **111.6** |
* *Score, same GPU* uses the baseline as measured above; *score, published baseline* is the
kit's own number, whose speed term compares against the organisers' TPOT from different
hardware (that is why the baseline itself gets 96.2 there).
* The same-GPU score splits into acceptance 1.053 (×0.5), memory 1.5 (×0.25, the cap) and
speed 1.010 (×0.25). Fine-tuning added +0.095 to τ, mostly in long-form writing (+0.14) and
math (+0.07); chat and code were already close to what one head layer can reach.
* The offline simulator predicted the dev acceptance within 0.02 of the engine (2.884 vs
2.900 for the draft, 2.793 vs 2.805 for the baseline).
* r2 trained on 4.06 M generated tokens (9,634 answers) for 1,190 steps (2 epochs, 27 min);
validation τ was still rising at the last step. The whole pipeline, including two full
evaluations, took about 3 hours of GPU time.
Earlier run **r1** (2.02 M tokens, 584 steps) reached τ 2.868 and a same-GPU score of 114.4
(bf16 variant: τ 2.885, score 102.3). Twice the data gave +0.03 τ.
Raw kit outputs, per-stage logs, machine statistics and training summaries are in the
dataset repo under `runs/r1/` and `runs/r2/`; the r2 draft folders (FP8 and bf16, each with
`model.safetensors`) under `submissions/r2/`.
## Phase 2 submission
The r2 FP8 draft is in a gated Hugging Face model repository (manual approval, organizers
only), identical to `submissions/r2/main-fp8` and passing `emc2 validate`:
```
mudassiruddin21/EMC-Qwen3.8-27B-MTP-FP8@21a87b7316a9217c32f840223ccf5ca61001dafb
```
## Layout
```
emcdraft/head.py MTP head re-implementation, K-step unroll, FP8 rounding/encoding, export
emcdraft/prompts.py training prompts per domain, dev-overlap filter, template check
emcdraft/gen_vllm.py greedy answers of the target with the serving engine
emcdraft/target.py reference implementation wrapper: final hidden states (teacher forcing)
emcdraft/extract.py hidden-state shards, agreement check, simulator check on the baseline
emcdraft/sim.py offline acceptance simulator, feature shards
emcdraft/train.py fine-tuning (recursive objective, optional FP8 QAT), export
emcdraft/probe.py untrained FP8 copy of the baseline (engine loading probe)
scripts/kit.py runs the official kit commands without a container runtime
scripts/pipeline.sh end-to-end, resumable pipeline (one stage per step, logs per stage)
scripts/supervise.py unattended driver: code updates, control requests, log uploads
scripts/launch.py starts the driver on a GPU machine (or prints its status)
scripts/sync.py pushes logs / results / draft folders to the Hugging Face dataset repo
scripts/collect.py results/summary.{json,md}
control/ stage re-run requests and budget settings read by the driver
tests/test_head.py CPU self-test (FP8 codec, unroll vs. step-by-step emulation, export)
```
## Reproduce
Linux, one GPU with at least 80 GB, about 120 GB of disk. In a Python shell or notebook on
that machine:
```python
import os, urllib.request
os.environ["HF_TOKEN"] = "<token with write access to the results repo>"
exec(urllib.request.urlopen(
"https://raw.githubusercontent.com/Mudassiruddin7/EMC/main/scripts/launch.py").read(),
{"__name__": "__main__"})
```
This starts `scripts/supervise.py`, which runs `scripts/pipeline.sh` stage by stage:
| stage | what it does |
|---|---|
| env | private Python 3.12 environment with `vllm==0.31.0` |
| download | the kit (pinned commit) and the target at the kit's pinned revision |
| baseline | `emc2 prepare-baseline` + `validate` |
| probe, smoke_fp8 | FP8 copy of the untrained baseline head through the official `eval` (2 prompts per domain) |
| prompts | training prompts (runs in parallel with the GPU checks) |
| generate | greedy answers with the engine (token budget `GEN_TOKENS`) |
| extract | hidden states + agreement and simulator checks |
| train | fine-tuning, export of `sub_fp8` / `sub_bf16`, `validate` |
| eval_main, eval_baseline, eval_alt | full official `eval` (160 dev prompts) of the draft, the baseline and the second variant |
Every stage resumes after an interruption, and logs, kit results, generated data and the
draft folders are pushed to the dataset repo as they are produced. Settings in
`control/run.env` extend a finished run instead of repeating it: `GEN_APPEND=1` and
`EXTRACT_APPEND=1` keep earlier answers and features, `TRAIN_INIT` starts from an earlier
head, `RUN_NAME` names the new training run.
The engine is the pinned version installed from PyPI rather than the container image; the
results JSON records this. The pipeline sets `VLLM_USE_FLASHINFER_SAMPLER=0`, so the engine
uses its built-in sampler instead of compiling FlashInfer's at start-up; decoding is greedy,
so outputs and draft behaviour are unaffected. `python tests/test_head.py` runs the CPU
self-test (no GPU, no downloads).
## Submission format and rules
Each exported folder (`runs/main/sub_fp8`, `runs/main/sub_bf16`) contains `config.json` (the
target's, byte-identical), `model.safetensors` (only `mtp.*` tensors), `spec.json`
(`{"method": "mtp"}`) and `metadata.json`, and passes `emc2 validate`. No code, no pickle,
no state across requests; verification is untouched. The head is initialised from the
target's built-in MTP head (the baseline draft itself) and shares the target's embedding and
output layer, as the baseline does; no target decoder layers are copied.
## License
Apache-2.0, like the target model and the engine.
|