ZipDepth: a 6.1M-parameter zero-shot depth model built for phones as well as GPUs

What the model is aiming at

ZipDepth is the official implementation of an ECCV 2026 paper from the University of Bologna, authored by Fabio Tosi, Luca Bartolomei, Matteo Poggi and Stefano Mattoccia, with the arXiv identifier 2607.08771. The claim is a compact 6.1M-parameter network for zero-shot monocular depth estimation that runs in real time from server GPUs down to mobile phones, trained by knowledge distillation from foundation models.

The positioning is deliberately narrow. The README claims the best accuracy to efficiency trade-off among lightweight methods, approaching transformer-based foundation models at a fraction of their cost, and reports state-of-the-art accuracy among lightweight embedded models on NYUv2, KITTI, ETH3D, ScanNet and DIODE. Code and pretrained weights were released in July 2026, and the project page shows it running live on an iPhone.

The encoder, stage by stage

The encoder runs in four hierarchical stages. Stages 1 and 2 use RepVGG reparameterizable blocks, where a 3x3 branch, a 1x1 branch and an identity branch are fused into a single 3x3 convolution at inference, augmented with Strip Pooling Attention for horizontal and vertical context. Stage 3 adds Squeeze-and-Excitation channel attention and a Global Context Block. Stage 4 deepens the representation with further RepVGG blocks.

The reparameterization is the part that matters for deployment. Training-time multi-branch blocks give the optimizer something to work with, and inference-time fusion collapses them into one plain convolution, so the speed you measure at inference carries no branch overhead.

Neck, decoder and the convex upsampling head

The neck combines SPPF multi-scale pooling with a Cross-Scale Fusion module. The decoder is a lightweight FPN whose head does convex upsampling, which the README pairs with the claim of sub-pixel-accurate depth maps.

How much work that head is doing becomes obvious from the checkpoints. The mobile variant exists because the unfold operation behind convex upsampling is not NPU-friendly, which means the step is load-bearing rather than cosmetic: if it were cheap to replace, there would be no reason to ship a second checkpoint that differs in exactly that operation.

Two checkpoints that differ in one operation

Pretrained weights ship in the repository under checkpoints/, and both variants are about 6.1M parameters with identical encoder and decoder weights. They differ in exactly one place, the final upsampling step.

zipdepth_base.pth uses torch.nn.Unfold for sub-pixel convex upsampling and is the one to use on a GPU or server, where the README says accuracy is best. zipdepth_base_npu.pth replaces the unfold operation with an NPU-friendly equivalent, and is the one for ONNX export targeting mobile or edge devices.

Shipping the pair is the honest way to handle this. Most projects quietly assume a GPU and leave mobile exporters to discover the unsupported operator themselves.

Installing it and running a first inference

Requirements are Python 3.9 or newer, PyTorch 2.4 or newer, and CUDA where available:

git clone https://github.com/fabiotosi92/ZipDepth
cd ZipDepth
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt
pip install -e .

The README warns that requirements.txt installs the default PyTorch wheel, which on Linux ships with a bundled CUDA runtime, so if you need a specific CUDA version or a CPU-only build you install PyTorch from the official selector first and then run pip install -r requirements.txt.

Then run inference on a single image:

python scripts/infer.py \
  --checkpoint checkpoints/zipdepth_base.pth \
  --input assets/examples/im0.jpg \
  --input-size 384

The same script takes a folder or a video file as --input. --input-size defaults to 384 and sets the shorter side, preserving aspect ratio and rounding to the nearest multiple of 32, so 384, 512 and 768 are the natural values. --output is auto-named if you leave it out, and --fp16 is off by default.

Optional dependencies and the training data

Three optional installs are documented: PyTurboJPEG for faster JPEG decoding, fvcore and thop for FLOPs measurement in the benchmark, and onnx plus onnxsim for graph simplification during export.

The v1.0 release, published on 2026-06-26, shipped code, pretrained checkpoints and a training file list, training_files.txt.gz, covering 14,069,951 images across 17 domains. That number tells you what the distillation actually cost, and it is the main reason not to expect to retrain this on a laptop.

Licence, maintenance and when to look elsewhere

ZipDepth is MIT licensed, which is the permissive end of the scale for a research release and unusual enough to be worth stating. The last push was on 2026-08-22.

Look elsewhere if you have a fixed camera setup and a labelled domain where fine-tuning is possible, because a larger foundation model tuned to your data will beat this on accuracy. The value here is the trade-off rather than the peak.

Editorial conclusion

Adopt ZipDepth if you need monocular depth on hardware that cannot host a transformer foundation model: 6.1M parameters, MIT licensed, and two checkpoints so the mobile export path is already thought through. Look elsewhere if you can afford a larger model and care about peak accuracy, or if you plan to retrain, because the v1.0 training list covers roughly 14 million images. Verify with zipdepth_base_npu.pth and an ONNX export before committing to a mobile target, since the unfold operation in the base checkpoint is what stops those exports.

Frequently asked questions

Official sources

1. fabiotosi92/ZipDepth on GitHub
2. License: MIT
3. Project website
4. README
5. Releases