DSperse Overview: targeted, practical zero-knowledge for real ML inference

Slice your model, verify what matters. A pragmatic path to verifiable ML that fits real-world resources.

Introduction

Full zero-knowledge verification of large ML models is computationally expensive, memory-intensive, and slow to produce — it requires complex circuitization and heavy prover work that dramatically increases latency and hardware requirements compared to normal inference. In many real-world cases full end-to-end verification is overkill when only specific subcomputations (e.g., safety checks, IP-sensitive heads, or decision thresholds) actually require cryptographic guarantees.

This is why we engineered DSperse, a modular framework that addresses this by targeted verification: rather than circuitizing an entire model, DSperse lets you circuitize and prove high-value subcomputations — or “slices” — dramatically cutting memory and proof time while preserving verifiability where it matters. The architecture of DSperse is shown in Fig. 1.

Fig 1. The architecture of DSperse

Why DSperse?

Full-model zK inference is often impractical — circuitization cost, proof latency, and fidelity loss make many real-world models infeasible to verify end-to-end. Consider a financial fraud pipeline scenario where a large ML model, which is retrained weekly, scores transactions and an accompanying rule-based module decides whether to block a transaction:

• What you don’t prove: the whole ML model (would require repeated, costly recompilation whenever weights change).
• What do you prove: the anomaly-detection slice and the decision rule output. For each transaction, the pipeline produces: (a) the model’s score passed to the anomaly detector, (b) the anomaly detector’s output, and (c) the decision module’s output.

DSperse generates a per-slice proof that the anomaly detector and the decision rule were executed correctly on the provided inputs and that the decision follows the proven outputs.

Experiments and Results

To demonstrate this flexibility, we benchmark DSperse using a LeNet-5 style CNN adapted to CIFAR inputs (batch of 70 images) and two distinct proving systems: EZKL, a Halo2-based proving system with mature tooling, including a public CLI and support for ONNX model import and JSTProve, an internal, research-stage proving system built using Polyhedra Network’s Expander Compiler Collection. Slicing decomposed LeNet into five contiguous slices (two conv blocks + three FC blocks).

Core Technical Facts

Modularity:

• Prover-agnostic. support backends like EZKL, JSTProve (and future JOLT/Noir/JSTProve improvements) plug in per-slice.
• Interchangeable components: slicing module, circuit generation, backend adapter, proof orchestration.
• Supported models: Conv + FC networks (LeNet family). ResNet experiments in progress.

Memory usage results:

• In the sliced configuration, total memory usage for proof generation drops by approximately 38%.
• Mean memory usage during verification falls by roughly 45% under slicing.

We anticipate that the relative memory savings observed here may scale favorably with larger models, as the overhead associated with monolithic circuit construction and execution grows with network depth and width.

Timing results:

• Witness generation time drops by roughly 77% in the per-slice setting, while proof generation time decreases by approximately 66%.
• Verification time shows a more modest improvement, falling by about 38%.

These gains reflect the smaller circuit size and lower computational burden associated with proving just a portion of the model. The full result tables and repo links will be available in Part 2 follow up to this article.

Summary

DSperse enables strategic verifiability — prove the high-value parts and leave the rest as normal inference (or audited), reducing cost and preserving fidelity. The proofs are much smaller and faster to generate, don’t require re-circuitizing the entire model after retraining, and give auditable guarantees for the high-risk parts of the pipeline (the detector and the final decision in our scenario).

Full details in our new whitepaper: DSperse: A Framework for Targeted Verification in Zero-Knowledge Machine Learning.