Monokulare Tiefenschätzung#

Die monokulare Tiefenschätzung sagt eine pro Pixel berechnete Tiefenkarte aus einem einzelnen RGB-Bild voraus. Jeder Ausgabepixel enthält einen Tiefenwert in Metern, der die geschätzte Entfernung von der Kamera zu diesem Oberflächenpunkt darstellt.

Die Ausgabe eines Tiefenmodells ist eine dichte Gleitkommakarte der Form (H, W), die an das Eingabebild angepasst ist. Diese pixelweise Darstellung prädestiniert die monokulare Tiefenschätzung für die 3D-Szenenrekonstruktion, Roboter-Navigation, AR/VR-Inhaltserstellung und jede Anwendung, die ein räumliches Layout von einer einzelnen Kamera erfordert.

Models#

YOLO26-Tiefenmodelle, die auf einem breiten Multi-Dataset-Mix (innen + außen, ~2,19 Mio. Bilder) vortrainiert wurden, sind unten aufgeführt. Die Metrikspalten werden auf dem NYU Depth V2 Eigen-Testsplit angegeben.

Modelle werden bei der ersten Verwendung automatisch aus dem neuesten Ultralytics-Release heruntergeladen.

• delta1^NYU ist der Prozentsatz der Pixel, bei denen die vorhergesagte Tiefe innerhalb eines Faktors von 1,25 der Ground Truth liegt, auf dem NYU Depth V2 Eigen-Test-Split (654 Bilder) mit Multi-Scale + horizontal-flip TTA und Log-Least-Squares-Ausrichtung.
• Die Genauigkeit auf einer Skala ohne TTA ist mit yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 reproduzierbar (ersetze model= für jede Größe), was eine medianbasierte (nur skalenbezogene) Ausrichtung verwendet und niedriger abschneidet: delta1 0.783 (n), 0.793 (s), 0.840 (m), 0.853 (l), 0.860 (x).
• abs_rel ist der mittlere absolute relative Fehler zwischen den vorhergesagten und den Ground-Truth-Tiefenwerten.
• rmse ist der quadratische Mittelwert des Fehlers in Metern.
• Geschwindigkeit ist die reine Inferenzlatenz (ohne Vor-/Nachbearbeitung) bei imgsz=768, batch=1, angegeben als Mittelwert ± Standardabweichung über zeitgesteuerte Durchläufe nach dem Aufwärmen. CPU ONNX ist ONNX Runtime fp32 auf einem Intel Xeon mit 32 Kernen (Skylake); T4 TensorRT10 ist TensorRT fp16 auf einer Tesla T4.
• params und FLOPs werden bei 768×768 gemessen, der Trainingsauflösung der veröffentlichten Gewichte.

Geschwindigkeit im Vergleich zu Depth Anything V2#

Depth Anything V2 ist eine weit verbreitete offene Baseline für monokulare Tiefe. Dessen DINOv2-Vision-Transformer-Backbone und DPT-Decoder sind rechenintensiv, sodass auf derselben Tesla T4 unter TensorRT fp16 das kleinste veröffentlichte Depth Anything V2-Modell langsamer ist als jedes YOLO26-Tiefenmodell – einschließlich YOLO26x-depth, das mehr als doppelt so viele Parameter aufweist.

Bei ~768 px – imgsz=768 für YOLO26, der Auflösung, bei der die veröffentlichten Gewichte trainiert wurden, und 770 px für Depth Anything V2, dessen DINOv2-Backbone ein Vielfaches seiner Patch-Größe von 14 erfordert:

Bei ~640 px – imgsz=640 beziehungsweise 644 px – bleibt die Reihenfolge unverändert, und YOLO26n-depth ist 5,9× schneller als Depth Anything V2 Small:

• Die Latenz ist reine Inferenz, batch=1, TensorRT fp16 auf einer Tesla T4 – derselbe Versuchsaufbau wie in der Modelltabelle oben, hier auf zwei Dezimalstellen angezeigt; FPS ist der Kehrwert der ungerundeten Latenz. Die Speedup-Spalten teilen die Latenz von Depth Anything V2 Small (20,99 ms) und Base (55,40 ms) durch die YOLO26-Latenz.
• Depth Anything V2 Small und Base sind die veröffentlichten ViT-S- und ViT-B-Checkpoints.
• Der Vergleich deckt nur die Latenz ab – die beiden Modellfamilien werden hier nicht nach einem gemeinsamen Genauigkeitsprotokoll evaluiert.

Tiefenbereich und der Log-Tiefen-Head#

Der Tiefenkopf sagt exp(logit) voraus – ungebunden (~0,02–150 m) – und entkoppelt die Szenenform von der absoluten Skala: Das Netzwerk sagt ein relatives Protokoll-Tiefenfeld voraus, und absolute Meter werden durch eine separate Zwei-Parameter-Transformation (exp(a·log d + b)) festgelegt, die bei der Auswertung, durch leichte Kalibrierung oder durch Fine-Tuning ermittelt wird. Die gängige Alternative, ein gebundener sigmoid × max_depth-Kopf, baut stattdessen eine feste Obergrenze in die Architektur ein, sodass jede Tiefe jenseits von max_depth abgeschnitten wird – was das Training auf und die Vorhersage von Szenen mit größerer Reichweite verhindert.

Warum der Head unbegrenzt ist: Nachweise über Tiefenbereiche hinweg#

Kontrolliertes A/B — gleiche Daten, gleicher Zeitplan, nur der Head unterscheidet sich. Training beider Heads von Grund auf mit einer identischen Mischung aus Innen- (≤10 m) und Außendaten (≤80 m):

Der gebundene Kopf kann die Mehrheit der Außenpixel (>10 m) nicht darstellen, sodass er fast sofort aufhört sich zu verbessern; der log-Kopf lernt aus dem gesamten Bereich.

Der Fehlerfall, den er behebt — Einzeldatensatz-Feinabstimmung, stratifiziert nach Bereich. Das Feinabstimmen eines begrenzten (10 m) Heads auf einzelnen Datensätzen funktioniert, wenn die Daten in das Limit passen, und bricht zusammen, wenn sie es überschreiten:

Der Zusammenbruch landet exakt an der Obergrenze. Der log-Kopf hat keine solche Grenze.

Veröffentlichte Modelle – bereichsübergreifende Leistung. Die ausgelieferte Familie mit log-Kopf, bewertet über Benchmarks von 10 m (NYU, iBims-1) bis 80 m (KITTI), mit skalenangepasstem δ1:

Beide Spalten entsprechen den Veröffentlichungen. Die anderen Zeilen werden mit dem TTA- und Log-Least-Squares-Protokoll bewertet, das auf ihren Datensatzseiten beschrieben ist und vom Validator in diesem Repo nicht implementiert wird, sodass die KITTI-Zeile nicht auf derselben Basis nachgemessen werden kann; die KITTI page enthält Werte, die auf dem kanonischen 652-Frame-Eigen-Split gemessen wurden.

Die größten Gewinne liegen bei den länger reichenden Außen-Benchmarks (KITTI, ETH3D) — genau dort, wo ein festes 10-m-Limit am meisten schadet —, während die Innenraum-Leistung beibehalten wird.

Trainieren#

Trainiere YOLO26n-depth auf dem Depth8-Datensatz für 100 Epochen bei einer Bildgröße von 640. Eine vollständige Liste der verfügbaren Argumente findest du auf der Konfigurationsseite.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.yaml")  # build a new model from YAML
model = YOLO("yolo26n-depth.pt")  # load a pretrained model (recommended for training)
model = YOLO("yolo26n-depth.yaml").load("yolo26n-depth.pt")  # build from YAML and transfer weights

# Train the model
results = model.train(data="depth8.yaml", epochs=100, imgsz=640)

Weitere Details zum train-Modus findest du auf der Train-Seite.

Feinabstimmung auf eigenen Daten#

Wenn du ein vortrainiertes Tiefenmodell an einen benutzerdefinierten Datensatz anpasst, verringere die Lernrate und verwende den AdamW-Optimizer. Die Standardeinstellungen des Optimizers sind auf das Training von Grund auf (SGD mit lr0=0.01) abgestimmt; auf ein bereits konvergiertes Tiefenmodell angewendet, können sie das vortrainierte Wissen überschreiben und die Ergebnisse verschlechtern – insbesondere beim Fine-Tuning auf einer einzelnen Domäne.

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
)

Zusätzliche Tipps:

• Die Augmentierung wird über die Standardargumente (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v) gesteuert; die geometrische Verzerrung und die Spiegelungen werden identisch auf die gepaarte Tiefenkarte angewendet. Um das genaue Rezept einzusehen, das für die veröffentlichten YOLO26-Depth-Gewichte verwendet wurde, inspiziere die im Checkpoint gespeicherte train_args – siehe Inspecting YOLO26 Checkpoint Training Args.
• mosaic, mixup, cutmix und copy_paste sind für die Tiefe nicht implementiert. Der Tiefen-Datensatzlader setzt diese Wahrscheinlichkeiten automatisch auf 0, sodass deren Übergabe keine Wirkung hat. Diese Augmentierungen werden nicht unterstützt, da sie mehrere Bilder kombinieren, was ungültige gepaarte Tiefenkarten erzeugen würde.
• Jeder Tiefenbereich funktioniert sofort. Die Modelle mit log-Kopf sagen eine ungebundene Tiefe voraus, sodass sie sich ohne Änderungen an Nahbereichsdaten (Makro) oder Fernbereichsdaten (Außenbereich/Fahren) anpassen. Das Festlegen von max_depth: in deiner Datensatz-YAML (in Metern) begrenzt, welche GT-Pixel zu den Validierungsmetriken zählen.
• Allgemeine Leistung beibehalten. Wenn das Modell bei Szenen, die über deinen Trainingsdatensatz hinausgehen, genau bleiben soll, mische einen kleinen Teil (~5–10 %) vielfältiger Allzweckbilder in deine Trainingsdaten; dies reduziert das Vergessen während der Feinabstimmung erheblich.
• Trainiere von Grund auf (model=yolo26s-depth.yaml) nur dann, wenn sich deine Domäne stark unterscheidet und du über einen großen Datensatz verfügst – dort ist der Standard-SGD lr0=0.01 angemessen, da keine vortrainierten Gewichte zu erhalten sind.

Kalibrierung der Tiefenskala#

Der Tiefenkopf trennt Form (relative Szenenstruktur) von Skala (absolute Meter). Wenn ein Modell in deinen Szenen bereits eine gute relative Tiefe erzeugt, aber die absoluten Werte für deine Kamera nicht stimmen, kannst du die Skala in Sekundenschnelle mit model.calibrate() korrigieren – einer geschlossenen Anpassung einer log-affinen Zwei-Parameter-Funktion an einen kleinen markierten Satz, ohne Gradiententraining und ohne Änderung der Netzwerkgewichte, sodass die relative Struktur nicht verschlechtert werden kann.

from ultralytics import YOLO

model = YOLO("yolo26s-depth.pt")

# Fit scale on a labeled split (~100+ images is enough), then persist it
model.calibrate(data="path/to/your_dataset.yaml")
model.save("yolo26s-depth-calibrated.pt")

Die Kalibrierung benötigt Ground-Truth-Tiefe zum Anpassen, läuft also auf einem markierten Split ab – sie kann nicht bei einer blinden Inferenz stattfinden. Sie passt sich an dieselben Pixel an und bewertet diese, die auch die Val-Metriken auswerten: GT auf oder jenseits von max_depth der Datensatz-YAML (Standard 100 m) wird ausgeschlossen. Verwende sie, wenn die relative Tiefe bereits gut ist und nur die Skala/der Bereich falsch ist; wenn sich die relative Struktur für deine Domäne selbst ändern muss, nimm stattdessen Fine-Tuning vor.

Das Training erledigt dies automatisch für dich: Nach Abschluss von model.train(...) werden die besten und letzten Checkpoints auf dem Validierungssatz kalibriert, sodass sie standardmäßig metrisch skalierte Tiefe ausgeben.

Die veröffentlichten yolo26*-depth.pt-Checkpoints werden bereits mit dieser eingebauten Kalibrierung ausgeliefert, angepasst an den Validierungs-Mix des Vortrainings. Es handelt sich um eine einzige globale Skala über alle Domänen hinweg. Für die genaueste absolute Tiefe auf einer bestimmten Kamera oder einem bestimmten Szenentyp solltest du daher model.calibrate() auf einem kleinen markierten Split aus deinen eigenen Daten ausführen – dies ersetzt die integrierte Anpassung.

Datensatzformat#

Tiefenschätzungs-Datensätze paaren jedes RGB-Bild mit einer entsprechenden Tiefendatei. Tiefenziele werden als .npy-Arrays gespeichert, die float32-Werte in Metern enthalten. Die Datensatz-YAML verweist auf ein images/-Verzeichnis; der Lader leitet den Tiefendateipfad ab, indem er die Komponente images durch depth ersetzt und die Bilddateiendung durch .npy austauscht.

dataset/
├── images/
│   ├── train/
│   └── val/
└── depth/
    ├── train/
    └── val/

Beispielsweise ist ein Bild unter images/train/scene_001.jpg mit einer Tiefenkarte unter depth/train/scene_001.npy gepaart. Die vollständige Spezifikation des Formats findest du im Depth Estimation Dataset Guide.

Validieren#

Validiere die Genauigkeit eines trainierten YOLO26n-depth-Modells anhand eines Tiefenschätzungs-Datensatzes. Übergebe data explizit, damit die Validierung die beabsichtigte Datensatz-YAML verwendet. Die veröffentlichten Gewichte werden bei imgsz=768 trainiert, validiere und prognostiziere daher in dieser Größe für beste Genauigkeit.

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

# Validate the model
metrics = model.val(data="nyu-depth.yaml")
metrics.delta1  # percentage of pixels within threshold δ=1.25
metrics.abs_rel  # mean absolute relative error
metrics.rmse  # root mean squared error (meters)
metrics.silog  # scale-invariant logarithmic error

Vorhersagen#

Verwende ein trainiertes YOLO26n-depth-Modell, um Vorhersagen auf Bildern auszuführen.

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

Weitere Details zum predict-Modus findest du auf der Predict-Seite.

Ergebnisausgabe#

Die YOLO-Tiefenschätzung gibt ein Results-Objekt pro Bild zurück. Jedes Ergebnis speichert eine dichte Gleitkomma-Tiefenkarte für das gesamte Bild.

Aufgabenspezifische Results-Felder für alle Aufgaben findest du im Abschnitt Predict Results by Task.

Einfärben der Tiefenkarte#

Die rohe Tiefenkarte ist ein einkanaliges Gleitkomma-Array in Metern – nützlich für Berechnungen, aber schwer direkt zu lesen. Um sie in ein Farbbild umzuwandeln, verwende den colorize_depth-Helfer in ultralytics.utils.plotting, der das Tiefenarray (H, W) auf ein BGR-uint8-Bild (H, W, 3) abbildet (ungültige Pixel <= 0 werden schwarz dargestellt).

result.plot() überblendet diese Kolorierung bereits über das Eingabebild unter Verwendung der Standardwerte (cmap="jet", mode="disparity"); rufe colorize_depth direkt auf, wenn du ein eigenständiges farbiges Tiefenbild oder eine andere Farbkarte beziehungsweise Normalisierung wünschst.

import cv2

from ultralytics import YOLO
from ultralytics.utils.plotting import colorize_depth

model = YOLO("yolo26n-depth.pt")
result = model("https://ultralytics.com/images/bus.jpg")[0]

depth = result.depth.data.cpu().numpy()  # (H, W) float32, meters

# Colorize with near = warm and save
cv2.imwrite("depth_colored.png", colorize_depth(depth, cmap="spectral"))  # (H, W, 3) BGR uint8

# Fix the range to 0-20 m so the same color means the same distance across frames
cv2.imwrite("depth_metric.png", colorize_depth(depth, vmin=0.0, vmax=20.0, cmap="inferno", mode="metric"))

# Blended overlay straight from the Results object (uses cmap="jet", mode="disparity")
result.save("depth_overlay.png")

Jede Farbkarte verläuft von kühl/dunkel → warm/hell. mode entscheidet, welches Ende nah ist, und vmin/vmax sperren den Bereich über Frames hinweg, sodass eine Farbe immer denselben Abstand bedeutet.

Exportieren#

Exportiere ein YOLO26n-depth-Modell in ein anderes Format wie ONNX, CoreML, etc.

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

# Export the model
model.export(format="onnx")

Verfügbare Exportformate für die YOLO26-Tiefenschätzung sind in der folgenden Tabelle aufgeführt. Du kannst mit dem Argument format in jedes Format exportieren, d. h. format='onnx' oder format='engine'. Du kannst direkt auf exportierten Modellen prognostizieren oder validieren, d. h. yolo predict model=yolo26n-depth.onnx. Anwendungsbeispiele werden für dein Modell nach Abschluss des Exports angezeigt.

Weitere Details zum export-Modus findest du auf der Export-Seite.

FAQ#