Model reference · open weights

Fast-dDrive

LLMs Efficient-Large-Model Vision + text 1 build Open weights 68 dl/mo

Fast-dDrive is an open-weight language model from Efficient-Large-Model. Fast-dDrive (FP32) weighs 8.1 GB; the smallest configuration that runs it is RTX 3060 12 GB.

  • Fast-dDrive is a 235M parameter block-diffusion Vision-Language-Action model for end-to-end autonomous driving, built on Qwen2.5-VL-3B.
  • It uses section-aware structured-diffusion training and scaffold-aware speculative decoding to reach SOTA accuracy on the Waymo Open Dataset End-to-End Driving benchmark.
  • The model is released under the Apache 2.0 license.

Summary of the Efficient-Large-Model/Fast-dDrive model card, 2026-10-01

What it is

Released byEfficient-Large-Model
Released2026-05-30
Parameters235M
VRAM8.1 GB for the weights

What it runs on

Memory and cards for Fast-dDrive (FP32)

8.1 GBweights, file size
37 MBcache per 1K tokens
2.0 GBruntime overhead, at least
128,000 tokenscontext max
CardRequests at onceContext maxMemory
8K each32K each
RTX 3060 12 GB4139K11.6 GB
RTX 4060 Ti 16 GB174all 125K15.4 GB
RTX 3090 24 GB4310all 125K23.4 GB
RTX 4090 24 GB4310all 125K23.4 GB
RTX 5090 32 GB6917all 125K31.0 GB
L40S 48 GB11228all 125K44.0 GB
A100 80 GB22556all 125K78.2 GB
H100 80 GB21152all 125K78.1 GB
RTX PRO 6000 Blackwell 96 GB26365all 125K93.8 GB
DGX Spark (GB10) 128 GB unified30877all 125K107 GB
H200 141 GB409102all 125K138 GB
B200 180 GB534133all 125K176 GB
2× RTX 3060 12 GB
tensor parallel
369all 125K11.6 GB a card
Memory needed at each load
Requests at once8K tokens each32K tokens each
110.4 GB11.3 GB
511.6 GB16.2 GB
812.5 GB19.8 GB
1615.0 GB29.5 GB
3219.8 GB48.8 GB
6429.5 GB87.4 GB

One card, with vLLM's small-card settings.

From the model card

What Efficient-Large-Model says about Fast-dDrive

Read the model card

Fast-dDrive is a block-diffusion Vision-Language-Action (VLA) model for end-to-end autonomous driving, built on Qwen2.5-VL-3B. It pairs section-aware structured-diffusion training (SASD) with scaffold-aware speculative decoding (Scaffold Spec) and an optional shared-prefix multi-trajectory inference scaling scheme, and reaches SOTA accuracy on the Waymo Open Dataset End-to-End Driving (WOD-E2E) benchmark at over 200 tokens / second on a single H100.

Quick start

import torch
from transformers import AutoModelForCausalLM, AutoProcessor

MODEL = "Efficient-Large-Model/Fast_dDrive_3B"   # or your local clone

processor = AutoProcessor.from_pretrained(MODEL, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    trust_remote_code=True,
    dtype=torch.bfloat16,
).cuda().eval()

# Scaffold Spec (paper canonical, threshold = 0.0)
output_ids = model.scaffold_speculative_sample(
    input_ids=input_ids,
    attention_mask=attention_mask,
    pixel_values=pixel_values,
    image_grid_thw=image_grid_thw,
    confidence_threshold=0.0,
    block_size=32,
    max_new_tokens=512,
)

Inference paths

This release exposes three decoding paths as bound methods on the model:

MethodDescriptionThreshold
mdm_sample_deep_scaffoldSection Diffusion (SD) — iterative MDM denoising over a pre-filled JSON scaffold0.9
scaffold_speculative_sampleScaffold Spec (SS) — scaffold-aware self-speculative decoding (MDM draft + AR verify per block). Paper canonical.0.0
scaffold_spec_with_ss_multi_trajSS multi-rollout — shared-prefix N-rollout inference scaling on the trajectory section0.0

Important: scaffold_speculative_sample and its multi-traj variant must be run with confidence_threshold=0.0 to reproduce the paper numbers. Running at 0.9 silently degrades both ADE and throughput.

Headline results — WOD-E2E test set (single H100)

ModeRFS ↑ADE@3s ↓ADE@5s ↓TPS ↑Tok/Step ↑
Scaffold Spec7.8231.2542.907210.44.90
+ Inference scaling (N=4)7.8271.2402.821114.72.76

On the WOD-E2E val set, Scaffold Spec runs at 1919 ms / sample (4.1× over the AR baseline); fused with SGLang the same configuration drops to 665 ms / sample at 608.5 TPS — the 11.8× / 12× speedup over AR cited in the paper.

Files

  • modeling.py — model definition (Fast_dDriveForConditionalGeneration)
  • configuration.py — config classes
  • section_utils.py — scaffold construction + section-aligned block index utilities
  • generation_utils.py — the three inference paths, attached to the model class on import
  • config.json, generation_config.json, preprocessor_config.json, chat_template.jinja, tokenizer files — standard HF artifacts
  • model-0000{1..4}-of-00004.safetensors — model weights (4 shards)

Citation

@misc{zhang2026fastddriveefficientblockdiffusionvlm,
      title={Fast-dDrive: Efficient Block-Diffusion VLM for Autonomous Driving},
      author={Kewei Zhang and Jin Wang and Sensen Gao and Chengyue Wu and Yulong Cao and Songyang Han and Boris Ivanovic and Langechuan Liu and Marco Pavone and Song Han and Daquan Zhou and Enze Xie},
      year={2026},
      eprint={2605.23163},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2605.23163},
}

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms