DeFM: Learning Foundation Representations from Depth for Robotics

---

DeFM (Depth Foundation Model) is a vision backbone trained on 60M depth images via self-distillation. It is engineered for robotic perception, providing metric-aware representations that excel in sim-to-real transfer and cross-sensor generalization.

TL;DR - A DINO-style encoder, but for depth image inputs.

🌟 Key Features

• Large-Scale Pretraining: We pretrain on our curated dataset of 60 M depth images using self-distillation.
• Semantic Awareness: DeFM learns not only robust geometric priors but also semantically rich features from just depth images.
• Metric-Aware Normalization: Our novel three channel input normalization preserves metric depth across multiple scales.
• Compact efficient models: We distill our DeFM-ViT-L into a family of smaller efficient CNNs as small as 3M params for robot policy learning.
• Robotics Proven: Our encoder is proven effective for diverse robotic tasks such as navigation, manipulation and locomotion without task-specific fine-tuning.

🚀 Usage

Install the package from PyPI:

pip install defm

Loading through TorchHub only needs torch torchvision numpy huggingface_hub omegaconf.

1. Loading the Model

Load via TorchHub for easy integration:

import torch

# Load the 304M-parameter foundation model
model = torch.hub.load('leggedrobotics/defm:main', 'defm_vit_l14', pretrained=True)
model.eval().to("cuda")

or, with the defm package installed:

from defm.model_factory import create_defm_model

model = create_defm_model("defm_vit_l14", pretrained=True)  # weights from the Hugging Face Hub

2. Preprocessing

DeFM requires depth maps to be processed into our metric-aware 3-channel format.

from defm import preprocess_depth_image

# Depth in meters: (H, W) numpy array, tensor or PIL image. target_size is an int (square) or (H, W).
normalized_depth = preprocess_depth_image(metric_depth, target_size=518, patch_size=14).to("cuda")

3. Inference

with torch.no_grad():
    output = model.get_intermediate_layers(
        normalized_depth, n=1, reshape=True, return_class_token=True)

spatial_tokens = output[0][0] # (B, C, H', W')
class_token = output[0][1] # (B, C)

The CNN models (defm_resnet50, defm_efficientnet_b0, ...) return a dict instead, and their input height and width must be multiples of 32:

model = torch.hub.load('leggedrobotics/defm:main', 'defm_resnet50', pretrained=True).eval().to("cuda")
normalized_depth = preprocess_depth_image(metric_depth, target_size=(224, 320)).to("cuda")

with torch.no_grad():
    output = model(normalized_depth)

class_token = output["global_backbone"]  # (B, C)
spatial_tokens = output["dense_bifpn"]["P4"]  # (B, C, H/16, W/16), the features distilled from the ViT

For more details, visit our GitHub repository.

📊 Model Zoo

The following table provides a comprehensive overview of the DeFM model family, including architectural parameters, inference latency across training and deployment hardware (224x224), and performance on the ImageNet-1k-Depth benchmark.

Model	Params (M)	RTX 4090 BS-128 (ms)	Jetson Orin (ms)	Top-5 KNN (%)	Linear Prob (%)	Checkpoint
DeFM ViT-L/14	303.7	624.91	72.82	85.42	72.76	Download
DeFM ViT-S/14	21.6	63.76	11.92	79.37	62.74	Download
DeFM ResNet-50	26.2	69.39	17.79	78.93	62.56	Download
DeFM ResNet-34	23.3	33.08	13.54	73.84	54.78	Download
DeFM ResNet-18	11.7	21.06	8.67	70.93	51.57	Download
DeFM EfficientNet-B6	28.98	150.98	54.11	79.30	60.70	Download
DeFM EfficientNet-B4	14.16	86.51	39.67	76.45	56.24	Download
DeFM EfficientNet-B2	4.95	46.12	28.37	72.89	51.64	Download
DeFM EfficientNet-B0	3.01	29.39	21.04	69.54	47.17	Download
DeFM RegNetY-1.6GF	12.4	44.25	41.82	77.96	58.88	Download
DeFM RegNetY-800MF	6.3	25.21	24.16	76.43	58.62	Download
DeFM RegNetY-400MF	4.1	17.27	25.17	74.43	51.80	Download

---

📏 Benchmarks

benchmarks/ reproduces the linear-probe evaluations of the paper for DeFM and all image baselines (DINOv2, DINOv3, Depth Anything V2, C-RADIOv3, Theia), loading every model from its official Hugging Face weights:

git clone https://github.com/leggedrobotics/defm && cd defm
pip install -e ".[benchmarks]"
python -m benchmarks.segmentation --encoder defm_vit_l14 --dataset tartanground   # ScanNet, SUN RGB-D, OFFSED, TartanGround, GraspNet
python -m benchmarks.classification --encoder defm_vit_s14 --eval knn linear     # ImageNet-1k-Depth

TartanGround, GraspNet-1Billion and ImageNet-1k-Depth are downloaded from the Hub; ScanNet, SUN RGB-D and OFFSED are built from their official releases with the scripts in scripts/datasets/. See the benchmark README for datasets, protocol and results.

---

📖 Citation

If you find DeFM useful for your research, please cite our paper:

@misc{patel2026defm,
      title={DeFM: Learning Foundation Representations from Depth for Robotics}, 
      author={Manthan Patel and Jonas Frey and Mayank Mittal and Fan Yang and Alexander Hansson and Amir Bar and Cesar Cadena and Marco Hutter},
      year={2026},
      eprint={2601.18923},
      archivePrefix={arXiv},
      primaryClass={cs.RO},
      url={https://arxiv.org/abs/2601.18923}, 
}