README.md

---
license: mit
library_name: onnx
tags:
- depth-estimation
- midas
- mobile
- edge
- onnx
base_model: isl-org/MiDaS
pipeline_tag: depth-estimation
language:
- en
---

# MiDaS v2.1 Small — Monocular Depth Estimation (ONNX)

ONNX checkpoint of [Intel ISL's MiDaS v2.1 small](https://github.com/isl-org/MiDaS) — an EfficientNet-Lite3 encoder paired with a lightweight depth decoder. ~21M params, 256×256 input, CPU-friendly. Sibling to DPT-Large but ~16× smaller and ~20× faster on CPU.

Not converted locally — this is the ONNX file isl-org publishes directly in the [v2_1 GitHub release](https://github.com/isl-org/MiDaS/releases/tag/v2_1).

Credit: Intel Intelligent Systems Lab (MiDaS team — Ranftl, Lasinger, Hafner, Schindler, Koltun).

## What this repo contains

```
midas_v21_small_256.onnx   # ~80 MB — fp32, EfficientNet-Lite3 backbone, 256×256 input
```

A single ONNX file. No tokenizer, no preprocessor config — preprocessing is fixed by the architecture convention.

## Input / output

| | Spec |
|---|---|
| Input name | `input.1` (verify in Netron) |
| Input shape | `[1, 3, 256, 256]` (NCHW) |
| Input dtype | float32 |
| Input color order | **BGR** — note this differs from DPT-Large (which expects RGB) |
| Preprocessing | Resize to 256×256, scale to `[0,1]`, normalize with ImageNet stats: `mean=[0.485, 0.456, 0.406]`, `std=[0.229, 0.224, 0.225]` |
| Output shape | `[1, 256, 256]` |
| Output meaning | Single-channel **relative** depth (higher = closer, lower = farther). **Not metric.** Linearly map to your visualization range. |

## How to use

```python
import onnxruntime as ort
import numpy as np
from PIL import Image

sess = ort.InferenceSession("midas_v21_small_256.onnx")

# Resize, BGR (note: PIL is RGB by default — swap channels for MiDaS-small)
img = Image.open("photo.jpg").convert("RGB").resize((256, 256))
arr = np.asarray(img, dtype=np.float32) / 255.0
arr = arr[..., ::-1]                                                   # RGB -> BGR
arr = (arr - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225]            # ImageNet normalize
arr = arr.transpose(2, 0, 1)[None, ...].copy().astype(np.float32)      # NCHW

depth = sess.run(None, {sess.get_inputs()[0].name: arr})[0][0]         # 256x256
```

For metric depth, pair with a calibration scheme — MiDaS is trained for relative depth and will not give you "this object is 1.7 m away" without further work.

## When to pick MiDaS-small

- **Real-time, edge, CPU, or mobile**: ~50 ms / image on consumer CPU, ~80 MB on disk.
- **Coarse depth is enough**: relative ordering of "what's close vs far" matters more than fine boundary precision.
- **Pair with DPT-Large**: a common pattern is to run MiDaS-small first for a quick estimate, then fall back to DPT-Large only when high-quality depth is needed for a specific frame.

For sharper boundaries and higher absolute quality (at ~16× the disk + GPU latency), reach for `dpt-large` instead — same model family, same upstream lab.

## License

**MIT** — same as the upstream [isl-org/MiDaS](https://github.com/isl-org/MiDaS) repo. `LICENSE` file included.

Note: a separate Intel-published variant of DPT-Large lives on HuggingFace at `Intel/dpt-large` under **Apache-2.0**. Same model family, different distribution channel, different licenses. The checkpoint in *this* repo (v2_1 GitHub release) inherits MIT from the upstream GitHub repo.