Liquid AI's LFM2.5-VL DSpark Makes Vision AI 3.13x Faster on Apple Silicon

Liquid AI has released LFM2.5-VL-DSpark, an experimental draft model for its LFM2.5-VL-3B vision-language model. The companion model applies speculative decoding to multimodal inference, increasing token generation speed without changing the target model’s decoding distribution.

Speculative decoding pairs a small drafter with a larger target model. The drafter proposes several tokens, then the target verifies the block in one forward pass, accepts matching predictions, and corrects disagreements. This verification preserves the target model’s output distribution; deterministic decoding produces the same token sequence.

Liquid reports decode speedups of up to 2.66x on an Nvidia H100 and 3.13x on Apple Silicon. Maximum end-to-end gains reached 2.27x and 2.62x, respectively. Decode throughput measures token generation alone, while end-to-end throughput also includes image encoding and prompt processing.

Why images look like tokens to the drafter

The vision encoder converts an image into visual tokens before the language backbone processes them alongside text tokens. At that stage, both modalities exist as multidimensional tensors in the model’s hidden states, allowing DSpark to use the same speculative decoding method developed for text models.

DSpark reads hidden states from several layers of the target model and predicts a block of future tokens. The target evaluates that block once, yielding multiple output tokens from a pass whenever the draft predictions agree closely enough with its own distribution.

An 8.9% parameter overhead

The drafter adds approximately 280 million parameters, increasing the deployed parameter count by 8.9%. Embeddings and the language-model head remain tied to the 3B target model, so DSpark does not duplicate them.

• Four-layer decoder stack: 193.0M parameters
• Hidden-state projection: 21.0M parameters
• Markov head: 65.5M parameters
• Normalization and confidence head: 6.4K parameters

Liquid selected four drafter layers and a speculative block size of nine after running architecture ablations. The team recommends a block size of eight or nine for inference, depending on the hardware and runtime. All ablations and training runs used AMD hardware with Liquid AI’s training framework.

Three runtimes, up to 3.13x faster decoding

Liquid evaluated DSpark with the MMSpec benchmark across general visual question answering, text VQA, image captioning, chart VQA, complex reasoning, and multi-turn conversation. Tests used batch size 1, temperature 0, and FP16 or BF16 weights. The ranges below reflect variation across those task categories.

Acceptance counts remain similar across the three software stacks because the drafter and workload determine how often predictions match. Hardware and runtime determine how much time those accepted tokens save.

Higher-concurrency tests retained a throughput advantage, though the gap narrowed as batch sizes increased. Larger batches move decoding toward compute saturation, reducing the benefit of avoiding memory-heavy target-model passes.

Prefill sets the speedup ceiling

Each vision-language request includes three main stages: vision encoding, prompt prefill, and autoregressive decoding. DSpark accelerates only decoding. The vision encoder must still process the image, and the language backbone must still prefill the prompt plus hundreds of visual tokens.

Amdahl’s law limits the end-to-end gain when untouched stages consume much of the request time. Short-answer tasks over dense images spend a larger share of latency on vision encoding and prefill, especially on devices with lower compute throughput. Captioning, chart analysis, multi-turn chat, and long-form reasoning generate more output tokens, giving speculative decoding more work to accelerate.

Higher sampling temperatures also reduce the likely gain. A flatter token distribution increases disagreements between the drafter and target, lowering acceptance rates and requiring more corrections. The published benchmark uses greedy decoding at temperature 0, where acceptance and throughput are strongest.

Runtime support is already merged

Liquid publishes the drafter as Safetensors weights and GGUF weights. Integration changes have landed in llama.cpp, MLX-VLM, and SGLang.

• Pair DSpark with the corresponding LFM2.5-VL-3B target model.
• Start with a speculative block size of eight or nine.
• Measure decode and end-to-end latency separately.
• Benchmark with production prompt lengths, image sizes, temperatures, and concurrency.
• Budget 280M additional parameters, excluding the shared embeddings and language-model head.

Workloads that generate substantial responses can trade 8.9% more parameters for roughly 1.6x to 2.6x reported end-to-end throughput on the tested systems. Requests dominated by image processing, prefill, short answers, or high-temperature sampling should expect gains closer to the lower end of the measured range.