AR to diffusion conversion
- Score
- 0.3
- Wallet spend
- $8.44 of $10
- Model cost
- $7.97
- Agent time
- 3h 45m
- Steps
- 318
- Tokens in / out
- 129.1M / 505k
- Self-checks
- 4 passed of 4 used
- Rank at $10 wallet
- 5th of 14
Score
0.3raw metric 0.003714
The raw metric (accuracy on GPQA Diamond, MATH-500, LiveCodeBench v6 and MMLU-Pro) is rescaled so that chance on each benchmark scores 0 and the original autoregressive MiniCPM5-2B scores 100, clamped to that range; each of the 4 benchmarks is rescaled on its own and the score is their mean.
Benchmarks
| Benchmark | Raw | Floor | Ceiling | Normalized |
|---|---|---|---|---|
| gpqa_diamond | 0 | 0.250 | 0.672 | 0.0 |
| math_500 | 0.0120 | 0 | 0.980 | 1.2 |
| livecodebench_v6 | 0 | 0 | 0.648 | 0.0 |
| mmlu_pro | 0.00286 | 0.111 | 0.691 | 0.0 |
Verifier details
- metric
- four_benchmark_mean
- suite
- gpqa-math500-lcbv6-mmlupro-v6
- harmonic_mean
- 0
- scoring_deadline_seconds
- 79200
After grading, a reviewer model reads the submission's files and the agent's trajectory and checks each of the task's rules. A failed check makes the score 0. Step numbers link into the trajectory.
✓pinned base starttraining/setup_gpu.sh sets REV=12a3808a956f869c767195e9266b59c4d21d92e2 and curls the openbmb/MiniCPM5-2B config, tokeni
training/setup_gpu.sh sets REV=12a3808a956f869c767195e9266b59c4d21d92e2 and curls the openbmb/MiniCPM5-2B config, tokenizer and model-00000-of-00001.safetensors from huggingface.co/.../resolve/$REV. Phase 1 (training/run_train.sh) runs training/train.py with no --init-ckpt, so it calls dlm/model.py load_pretrained on those HF Llama weights. That function renames the weights and appends a [MASK] row initialized to the mean embedding. At step 1 the phase-1 log shows ar_ce≈0.99, as expected from a pretrained model. Phase 2 (training/run_train2.sh) starts with --init-ckpt from the phase-1 final checkpoint. The trajectory also records hashing the local base model against the pinned HF LFS oid. The shipped inventory (embed_tokens [130561,2048] plus 42 Llama-style layers) matches the converted checkpoint format.
✓no public benchmark eval trainingTraining data is 7 UltraData-SFT-2605 think training shards, packed by training/prep_data.py into 19539 windows (trainin
Training data is 7 UltraData-SFT-2605 think training shards, packed by training/prep_data.py into 19539 windows (training/data/packed40m_manifest.json). Benchmark files (GPQA, LCB tests, MATH-500, MMLU-Pro) are only turned into 13-gram shingles used to drop overlapping training records (Math 8, Code 86, Knowledge 2 dropped). Dev/selection data (dev_math64 and others) comes from held-out UltraData shards such as Math part-010 (trajectory#135), not from benchmark splits. Sources are declared in training/data_sources.md and training/fetch_sft.sh.
✓diffusion generationdlm/engine.py decodes in 8-token blocks. Each block starts filled with mask_id and gets bidirectional attention within t
dlm/engine.py decodes in 8-token blocks. Each block starts filled with mask_id and gets bidirectional attention within the block over a KV-cached prefix. On each step all masked positions are predicted in parallel, and _decide commits those with confidence ≥ threshold, or the top min_per_step most confident ones. Steps repeat until the block has no masks left, then the engine moves on. This is iterative masked block diffusion, not AR decoding. The model is trained with a noisy-stream masked objective (dlm/model.py forward_train, training/train.py).
✓actual inference uses reviewed weightsserve.sh execs python -m dlm.server --model-dir $HERE/model. dlm/server.py load_engine builds BlockDiffusionLM and calls
serve.sh execs python -m dlm.server --model-dir $HERE/model. dlm/server.py load_engine builds BlockDiffusionLM and calls load_dlm_checkpoint(model/model.safetensors), which enforces an exact key set (dlm/model.py). It then fuses the weights and serves them through DiffusionEngine (dlm/engine.py). The CUDA-graph path uses the same weights and the same _decide. The trajectory shows the shipped model/model.safetensors was scp'd from /root/work/ckpt2/final, with sha256 compared (trajectory#235, trajectory#236). The wheels in the trusted binary audits are approved upstream digests.
✓harness credentials used only by the harnessIn the trajectory, harness API keys and base URLs appear only in Spin docs/help output (trajectory#1 region). There are
In the trajectory, harness API keys and base URLs appear only in Spin docs/help output (trajectory#1 region). There are no direct model-API calls, no echoing or copying of harness credentials, and no extra harness CLI sessions. The participant used the Spin CLI for compute and storage. HF_TOKEN was used only to download the base model and datasets (training/fetch_sft.sh, training/setup_gpu.sh). training/s3_copy.py uses Spin wallet storage session credentials, which are not harness model credentials.
LLM adversarial review is not proof of arbitrary program behavior. Host storage and task-specific deterministic checks remain required.
frontier selfcheck runs the submission on the grading infrastructure against public examples and reports each gate, so the agent can catch problems before grading. Each run gets four. This agent used 4 of 4.
- 1passed3h 13m into the runtook 4m 30s
startup 92.9 s of 300 s; 1/1 gates passed; The suite's 32 concurrent requests per copy, up to 3600 s each, were not sent; one request at its settings was.
5 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 92.9 s
- ✓single-stream speed · 8 of 8 measured prompts, sent one at a time after an untimed warm-up (max_tokens 1024, temperature 1), each reply's reasoning and answer tokens counted with the pinned openbmb/MiniCPM5-2B tokenizer over end-to-end request time (sandbox clock), a miss re-sent once; slowest 590 tokens/s (982 tokens in 1.66 s); per prompt: 590, 596, 625, 633, 685, 612, 597, 604. Public prompts: 7 GPQA and 2 hard LiveCodeBench; grading draws 4 GPQA, 3 level-5 MATH-500 (held out) and 2 hard LiveCodeBench, so its replies differ.
- ✓GPQA request as graded (self-check cap 291 s; grading allows 3600 s) · {"finish_reason": "stop", "answer": null, "note": "no answer letter found (ANSWER: X on its own line): grading scores it wrong", "content_characters": 8830, "reasoning_characters": 536, "content_end": "rix }{\n{bmatrix{bmatrix } }{bmatrix{bmatrix =\n{bmatrix\n\n ]{bmatrix -1{b{bmatrix ...[clipped]
- ✓healthy after requests
- 2passed3h 23m into the runtook 6m 37s
startup 83.8 s of 300 s; 1/1 gates passed; The suite's 32 concurrent requests per copy, up to 3600 s each, were not sent; one request at its settings was.
5 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 83.8 s
- ✓single-stream speed · 8 of 8 measured prompts, sent one at a time after an untimed warm-up (max_tokens 1024, temperature 1), each reply's reasoning and answer tokens counted with the pinned openbmb/MiniCPM5-2B tokenizer over end-to-end request time (sandbox clock), a miss re-sent once; slowest 499 tokens/s (962 tokens in 1.93 s); per prompt: 520, 531, 499, 526, 521, 518, 525, 519. Public prompts: 7 GPQA and 2 hard LiveCodeBench; grading draws 4 GPQA, 3 level-5 MATH-500 (held out) and 2 hard LiveCodeBench, so its replies differ.
- ✓GPQA request as graded (self-check cap 291 s; grading allows 3600 s) · {"finish_reason": "length", "note": "cut off at max_tokens: grading scores such a reply zero", "content_characters": 0, "reasoning_characters": 0, "content_end": ""}
- ✓healthy after requests
- 3passed3h 33m into the runtook 4m 58s
startup 100.2 s of 300 s; 1/1 gates passed; The suite's 32 concurrent requests per copy, up to 3600 s each, were not sent; one request at its settings was.
5 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 100.2 s
- ✓single-stream speed · 8 of 8 measured prompts, sent one at a time after an untimed warm-up (max_tokens 1024, temperature 1), each reply's reasoning and answer tokens counted with the pinned openbmb/MiniCPM5-2B tokenizer over end-to-end request time (sandbox clock), a miss re-sent once; slowest 497 tokens/s (983 tokens in 1.98 s); per prompt: 497, 512, 510, 523, 512, 500, 513, 509. Public prompts: 7 GPQA and 2 hard LiveCodeBench; grading draws 4 GPQA, 3 level-5 MATH-500 (held out) and 2 hard LiveCodeBench, so its replies differ.
- ✓GPQA request as graded (self-check cap 291 s; grading allows 3600 s) · {"finish_reason": "length", "note": "cut off at max_tokens: grading scores such a reply zero", "content_characters": 0, "reasoning_characters": 0, "content_end": ""}
- ✓healthy after requests
- 4passed3h 40m into the runtook 4m 34s
startup 96.5 s of 300 s; 1/1 gates passed; The suite's 32 concurrent requests per copy, up to 3600 s each, were not sent; one request at its settings was.
5 gates
- ✓review prerequisites
- ✓startup · GET /health answered 200 after 96.5 s
- ✓single-stream speed · 8 of 8 measured prompts, sent one at a time after an untimed warm-up (max_tokens 1024, temperature 1), each reply's reasoning and answer tokens counted with the pinned openbmb/MiniCPM5-2B tokenizer over end-to-end request time (sandbox clock), a miss re-sent once; slowest 504 tokens/s (820 tokens in 1.63 s); per prompt: 516, 507, 506, 512, 525, 513, 504, 516. Public prompts: 7 GPQA and 2 hard LiveCodeBench; grading draws 4 GPQA, 3 level-5 MATH-500 (held out) and 2 hard LiveCodeBench, so its replies differ.
- ✓GPQA request as graded (self-check cap 291 s; grading allows 3600 s) · {"finish_reason": "stop", "answer": null, "note": "no answer letter found (ANSWER: X on its own line): grading scores it wrong", "content_characters": 12028, "reasoning_characters": 1966, "content_end": " -\\sigma$.\n = $[ ] $ ] ].\n\nThen }\n ^text{}}}$.\n]} = ...[clipped]
- ✓healthy after requests
The agent's last message before its session ended.
The submission is in and graded as it stands in /workspace/output. It passes the server gates, but output quality is poor and the score will likely be low.
What was built
- MiniCPM5-2B (pinned revision, SHA-256 checked) converted to an 8-token block-diffusion model with a learned
[MASK]row. - Trained with a dual-stream objective: a clean causal stream for next-token loss, plus a noised stream with block-bidirectional attention. Data was training splits of
openbmb/UltraData-SFT-2605, decontaminated against GPQA-Diamond, LiveCodeBench v6, MATH-500 and MMLU-Pro. Two phases, about 24.5M tokens in total, on one H100. - Decoding runs iterative denoising: each step commits the most confident masked tokens (threshold 0.9, at least 3 per step), with a repetition penalty of 1.2.
serve.shinstalls vendored, unmodified cp312 wheels to/tmpand serves/v1/chat/completionsand/health.
Final selfcheck (25475702de8b, passed)
- Startup: 96.5 s against a 300 s limit.
- Single-stream speed: 503.8 tok/s against 450 (slowest of 8 prompts 504), so the margin is about 12%.
- The GPQA-style request finished with
stop, but its text is garbled and has noANSWER:line.
Choices I made
- Speed over quality. Hitting 450 tok/s forced about 2–3 committed tokens per step. On 32 held-out Math prompts with a 6144-token cap, accuracy was 0–6% for policies that met the speed gate. The one policy with better accuracy (28%) ran at about 190 tok/s and failed the gate.
- Budget. The $10 wallet limited training to about 25M tokens, so the denoiser is undertrained.
- Decode path. Single-stream decoding uses compiled per-layer halves with CUDA graphs. I checked this against the eager path to bf16 rounding.
- Dev data. Decoding settings were chosen on held-out training-split shards, never on GPQA, LCB, MATH-500 or MMLU-Pro.
Caveats
- The architecture review did not run during selfcheck and could still score the submission zero.
- Accuracy on the real benchmarks is unmeasured. It is likely near zero, because the outputs are garbled and often run to the token cap.
- The 3600-second and 22-hour limits were not stress-tested at 32 concurrent requests.
Provenance, download commands and logs are in training/ (data_sources.md, logs/), and architecture.json lists the evidence files.