Ultralytics YOLO26 now supports monocular depth estimation

Until now, adding depth to a YOLO pipeline meant assembling it yourself. The established pattern was to run YOLO for detection and pair it with a separate depth model from another project, such as MiDaS or Depth Anything. That meant a second dependency, a second framework, and two sets of input and output formats to reconcile.

Monocular depth estimation is now a native task in Ultralytics YOLO26. A single RGB image produces a distance value for every pixel, using the same package, workflow, and export path as detection, segmentation, and pose.

Link to this sectionWhat is depth estimation?#

Depth estimation predicts a per-pixel depth map from a single RGB image, without a second camera or additional sensor involved. Each output pixel holds a depth value in meters, representing the estimated distance from the camera to that surface point.

The output is a dense float map with shape (H, W), aligned to the input, where every pixel carries an absolute distance in metres; a distance from the camera, not a relative ordering of what is nearer and further.

Depth is a standalone task with its own checkpoint, and its output is the depth map alone; it does not return bounding boxes or segmentation masks. Combining detection with depth therefore requires running two models and two forward passes. What differs from previous practice is that both now sit within a single package, sharing one installation, one training and prediction interface, one export path, and a single version to track, rather than requiring a second framework to be maintained alongside the first.

That per-pixel output is what makes depth useful for obstacle and free-space detection, clearance checking, scene layout, and understanding what sits in front of what.

Fig 1. Ultralytics YOLO26 depth estimation for safety and compliance monitoring.

Ultralytics YOLO26 ships five pretrained depth models, from yolo26n-depth up to yolo26x-depth, trained on a broad multi-dataset mix spanning roughly 2.19M indoor and outdoor images. On the NYU Depth V2 set, they range from 0.882 δ1 accuracy on the nano model up to 0.933 on the extra-large model, so you can pick the tradeoff between speed and accuracy that fits your deployment target.

Link to this sectionUnbounded depth by design#

Most depth models cap their predictions at a fixed range, like 0–10 meters, which works fine for indoor scenes but breaks down outdoors. Ultralytics predicts depth on an open-ended log scale instead, with no hard cutoff.

The difference shows in testing. A capped model plateaus almost immediately when trained on mixed indoor and outdoor data, and falls apart on longer-range datasets like KITTI, where objects can be 80 meters away. YOLO26's approach has no such ceiling, so it keeps improving with more data and holds up from a few centimeters to a few hundred meters. On KITTI, δ1 reaches 0.942 at 80 m range. That means one model family handles a tabletop scene and a highway scene equally well.

Link to this sectionComparing Ultralytics YOLO26 depth vs. Depth Anything V2#

If you are running Depth Anything alongside YOLO today, the difference is speed and the compute bill that comes with it. YOLO26 depth runs up to 20.3× faster than Depth Anything V2 Base and 7.7× faster than Depth Anything V2 Small, from a much smaller model, under 10M parameters at nano, against roughly 24M for DA V2's smaller checkpoint.

Fig 2. Speed benchmarks for Ultralytics YOLO26 depth against Depth Anything V2.

That gap is the point of the design. Depth Anything V2's models are substantially larger; YOLO26-Depth is built for strong depth performance at a size and speed that costs less compute per frame and deploys onto hardware those models cannot reach. Per-model accuracy figures on NYU Depth V2 and KITTI are published in the docs, so you can check them against the requirement you actually have.

Link to this sectionWhere it runs#

That size difference is what determines where depth can actually go. Most teams evaluating depth are not short of ideas; they are short of compute. Low-power drones, quadruped robots, wearables, dashcams, conferencing hardware, and industrial PCs all hit a power and cost ceiling before they hit an accuracy ceiling.

Depth ships as five pretrained models, so you can pick the size that fits the target rather than the size that wins a benchmark. Because depth is a native YOLO26 task, it uses the same export path as detection, segmentation, and pose with the following formats: ONNX, TensorRT, CoreML, NCNN, LiteRT.

Link to this sectionGetting started with Ultralytics YOLO26 depth#

The Ultralytics Python package provides a single, unified interface for training, validating, and running inference across every YOLO26 task, including depth. Running a pretrained depth model takes a single command:

from ultralytics import YOLO

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.pt")  # load an official model
model = YOLO("path/to/best.pt")  # load a custom model

# Predict with the model
results = model("https://ultralytics.com/images/bus.jpg")  # predict on an image

# Access the results
for result in results:
    depth_map = result.depth.data.cpu().numpy()  # torch.Tensor → NumPy float32, shape (H, W), meters

Or from the CLI:

yolo depth predict model=yolo26n-depth.pt source='https://ultralytics.com/images/bus.jpg'  # predict with official model
yolo depth predict model=path/to/best.pt source='https://ultralytics.com/images/bus.jpg'   # predict with custom model

Absolute distance depends on your camera and your scene. If the shape of the depth map is right but the scale is off, model.calibrate() fits just two variables in the model's depth head, a scale and an offset, on around 100 labeled frames, in seconds, with no training and no change to the rest of the network.

Link to this sectionFine-tuning on your own data#

To adapt a pretrained depth model to your own camera or domain, start from the pretrained weights, use AdamW, and drop the learning rate well below the from-scratch default so fine-tuning refines the model instead of overwriting it:

from ultralytics import YOLO

from ultralytics import YOLO
model = YOLO("yolo26s-depth.pt")  # start from pretrained weights
model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,  # ~100x below the from-scratch default
    warmup_bias_lr=1e-4,  # keep warmup gentle too
)

Because the default log head is unbounded, this works out of the box whether your dataset is close-range or long-range, without needing max_depth tuning. If only the absolute scale is off for your specific camera, model.calibrate() fits a lightweight, closed-form correction on a small labeled split, in seconds, without touching the network weights.

Datasets pair each RGB image with a .npy depth file in a matching folder structure, and Ultralytics ships built-in configs for NYU Depth V2, KITTI, Hypersim, SUN RGB-D, and ARKitScenes, so most teams can start validating against a standard benchmark immediately.

For more information, check out our quickstart guide.

Link to this sectionKey use cases for depth estimation#

As this new feature can work from a single ordinary camera, monocular depth estimation opens up countless opportunities for products and industries that can't otherwise justify the cost, power draw, or calibration overhead of a stereo or LiDAR setup. So let’s take a look at some key industries and use cases that can benefit from this feature:

• Robotics and autonomous navigation. Mobile robots and drones can estimate obstacle distance and free space from a single onboard camera, supporting real-time path planning without dedicated depth hardware.
• Industrial and logistics awareness. Clearance checking, free-space detection, and shelf or aisle context from a single fixed camera, anywhere adding a second sensor is not practical.
• Safety and compliance monitoring. Forklift and warehouse safety zones, railway incident detection, fallen-person and object-left-behind detection on existing CCTV: distance context added to camera feeds that are already installed, alongside existing safety-certified sensors rather than in place of them.
• Infrastructure and asset inspection. Overhead-line clearance analysis, drone-based asset and corrosion inspection, and aerial survey work, where the same model family must handle both close-up detail and long-range scenes.
• Driver assistance and automotive perception. Long-range, unbounded depth output means the same model family that handles a close-up indoor scene also generalizes to 80 m+ driving scenes.
• AR and spatial content. Placing virtual objects believably in a real scene, or applying depth-aware effects, starts with knowing how far every pixel actually is from the camera.

Link to this sectionBringing depth estimation to every YOLO26 deployment#

With depth estimation now a native YOLO26 task, teams can leverage per-pixel distance from any RGB camera across industries, using the same train, val, predict, and export workflow they already know from detection, segmentation, and pose, and one less third-party dependency to maintain.

So as you scope your deployment with Ultralytics YOLO26 depth, let’s take a look at a few key points to keep in mind:

• Ultralytics YOLO Depth is built for RGB cameras. Any standard camera works, including webcams, phones, industrial cameras, or drones. However, other modalities such as LiDAR point clouds, radar, sonar, thermal and multispectral bands, or mesh and IFC data sit outside the model's input format.
• Metric distance for perception decisions. The output is a real distance in meters, making it well-suited for navigation, clearance, and monitoring. However, for any application where a certified tolerance is required, dedicated metrology equipment remains the right instrument.
• Per-image inference. Depth runs on each frame independently, consistent with every other YOLO26 task, therefore dropping into an existing per-frame pipeline without changes. Reasoning across a sequence stays in your application layer.
• Ultralytics YOLO26-Depth is strongest on textured, opaque surfaces. Glass, mirrors, standing water, polished metal, and open sky are inherently ambiguous for any single-camera method, so it is worth validating on scenes representative of your environment.

Curious about vision AI? Explore our licensing options to bring computer vision to your projects. Visit our GitHub repository to discover the full range of Ultralytics tasks and integrations, and check out Ultralytics Platform to start building your own end-to-end vision AI workflows.