Monokulare Tiefenschätzung mit Ultralytics YOLO#

Die monokulare Tiefenschätzung sagt aus einem einzelnen RGB-Bild eine Tiefenkarte für jedes Pixel voraus. Jedes Ausgabepixel enthält einen Tiefenwert in Metern, der die geschätzte Entfernung von der Kamera zu diesem Oberflächenpunkt angibt.

Die Ausgabe eines Tiefenmodells ist eine dichte Float-Karte der Form (H, W), die am Eingabebild ausgerichtet ist. Diese Darstellung für jedes Pixel eignet sich besonders für die 3D-Szenenrekonstruktion, die Navigation von Robotern, die Erstellung von AR/VR-Inhalten und alle Anwendungen, die aus einer einzelnen Kamera die räumliche Struktur benötigen.

Modelle#

Die folgenden YOLO26-Tiefenmodelle wurden auf einer breit gefächerten Mischung mehrerer Datensätze vortrainiert (Innen- und Außenbereiche, ~2,19 Mio. Bilder). Die Metrikspalten beziehen sich auf den Eigen-Testsplit von NYU Depth V2.

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 höchstens um den Faktor 1,25 von der Ground Truth abweicht, auf dem Eigen-Testsplit von NYU Depth V2 (654 Bilder) mit Multi-Scale- und horizontaler Spiegelungs-TTA sowie Log-Least-Squares-Ausrichtung.
• Die Genauigkeit bei einer einzigen Skalierung ohne TTA lässt sich mit yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 reproduzieren (ersetze model= durch die jeweilige Größe). Dabei wird eine Median-Ausrichtung (nur Skalierung) verwendet, und die Ergebnisse fallen niedriger aus: 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 Tiefenwerten und der Ground Truth.
• rmse ist der quadratische Mittelwert des Fehlers in Metern.
• Geschwindigkeit ist die reine Inferenzlatenz (Vor- und Nachverarbeitung ausgeschlossen) bei imgsz=768, batch=1, angegeben als Mittelwert ± Standardabweichung über Messläufe nach der Aufwärmphase. CPU ONNX bezeichnet ONNX Runtime fp32 auf einem Intel Xeon mit 32 Kernen (Skylake); T4 TensorRT10 bezeichnet TensorRT fp16 auf einer Tesla T4.
• params und FLOPs werden bei 768×768 gemessen, der Trainingsauflösung der veröffentlichten Gewichte.

Sieh dir die unreleased YOLO27 preview für vorläufige Ergebnisse zu NYU Depth V2 an.

Geschwindigkeit im Vergleich zu Depth Anything V2#

Depth Anything V2 ist eine häufig verwendete offene Baseline für monokulare Tiefe. Sein DINOv2-Vision-Transformer-Backbone und der DPT-Decoder benötigen viele Rechenressourcen. Daher ist das kleinste veröffentlichte Depth Anything V2-Modell auf derselben Tesla T4 mit TensorRT fp16 langsamer als jedes YOLO26-Tiefenmodell – einschließlich YOLO26x-depth, das mehr als doppelt so viele Parameter besitzt.

Bei ~768 px – imgsz=768 für YOLO26, der Auflösung, mit der seine veröffentlichten Gewichte trainiert wurden, und 770 px für Depth Anything V2, dessen DINOv2-Backbone ein Vielfaches seiner Patchgröß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 bezieht sich ausschließlich auf die Inferenz, batch=1, TensorRT fp16 auf einer Tesla T4 – derselbe Messaufbau wie in der obigen Modelltabelle, hier auf zwei Dezimalstellen gerundet; FPS ist der Kehrwert der nicht gerundeten Latenz. Die Spalten Beschleunigung teilen die Latenz von Depth Anything V2 Small (20,99 ms) beziehungsweise 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 betrachtet ausschließlich die Latenz – die beiden Modellfamilien werden hier nicht anhand eines gemeinsamen Genauigkeitsprotokolls bewertet.

Tiefenbereich und der Log-Tiefenkopf#

Der Tiefenkopf sagt exp(logit) voraus – unbegrenzt (~0,02–150 m) – und trennt die Szenenform von der absoluten Skalierung: Das Netzwerk sagt ein relatives Log-Tiefenfeld voraus, und die absoluten Meter werden durch eine separate Transformation mit zwei Parametern (exp(a·log d + b)) festgelegt, die bei der Evaluierung, durch eine einfache Kalibrierung oder durch Feinabstimmung ermittelt wird. Die gängige Alternative, ein begrenzter sigmoid × max_depth-Kopf, verankert stattdessen eine feste Obergrenze in der Architektur, sodass jede Tiefe jenseits von max_depth abgeschnitten wird – dadurch können Szenen mit größerer Reichweite weder trainiert noch vorhergesagt werden.

Warum der Kopf unbegrenzt ist: Evidenz über verschiedene Tiefenbereiche hinweg#

Kontrollierter A/B-Vergleich – dieselben Daten, derselbe Zeitplan, nur der Kopf unterscheidet sich. Beide Köpfe wurden von Grund auf mit einer identischen Mischung aus Innenbereichsdaten (≤10 m) und Außenbereichsdaten (≤80 m) trainiert:

Der begrenzte Kopf kann den Großteil der Außenbereichspixel jenseits von 10 m nicht darstellen und verbessert sich daher fast sofort nicht mehr; der log-Kopf lernt aus dem gesamten Bereich.

Der behobene Fehlerfall – Feinabstimmung auf einem einzelnen Datensatz, nach Bereich aufgeschlüsselt. Die Feinabstimmung eines begrenzten (10 m) Kopfes auf einzelnen Datensätzen funktioniert, wenn die Daten innerhalb der Obergrenze liegen, und bricht zusammen, wenn sie diese überschreiten:

Der Einbruch tritt genau an der Grenze der Obergrenze auf. Der log-Kopf hat keine solche Grenze.

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

Beide Spalten entsprechen den veröffentlichten Angaben. Die übrigen Zeilen werden mit dem auf den jeweiligen Datensatzseiten beschriebenen TTA- und Log-Least-Squares-Protokoll ausgewertet, das der Validator in diesem Repository nicht implementiert. Daher kann die KITTI-Zeile nicht unter denselben Bedingungen erneut gemessen werden; die KITTI-Seite enthält stattdessen Werte, die auf dem kanonischen Eigen-Split mit 652 Bildern gemessen wurden.

Die größten Verbesserungen zeigen sich bei den Außenbereichs-Benchmarks mit größerer Reichweite (KITTI, ETH3D) – genau dort, wo eine feste Obergrenze von 10 m am schädlichsten ist –, während die Leistung im Innenbereich erhalten bleibt.

Trainieren#

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

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)

Ausführliche Informationen zum Modus train findest du auf der Seite Trainieren.

Feinabstimmung mit deinen eigenen Daten#

Wenn du ein vortrainiertes Tiefenmodell an einen benutzerdefinierten Datensatz anpasst, senke die Lernrate und verwende den AdamW-Optimizer. Die Standardeinstellungen des Optimizers sind auf das Training von Grund auf ausgelegt (SGD mit lr0=0.01); bei einem bereits konvergierten Tiefenmodell können sie das vortrainierte Wissen überschreiben und die Ergebnisse verschlechtern – insbesondere bei der Feinabstimmung 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 Hinweise:

• Die Augmentierung wird über die Standardargumente gesteuert (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v); die geometrische Verzerrung und die Spiegelungen werden identisch auf die zugehörige Tiefenkarte angewendet. Um die exakte Vorgehensweise für die veröffentlichten YOLO26-Depth-Gewichte zu sehen, untersuche train_args, das im Checkpoint gespeichert ist – siehe Trainingsargumente eines YOLO26-Checkpoints untersuchen.
• mosaic, mixup, cutmix und copy_paste sind für die Tiefe nicht implementiert. Der Tiefendatenlader setzt diese Wahrscheinlichkeiten automatisch auf 0, daher hat ihre Übergabe keinen Effekt. Diese Augmentierungen werden nicht unterstützt, weil sie mehrere Bilder kombinieren und dadurch ungültige zusammengehörige Tiefenkarten erzeugen würden.
• Jeder Tiefenbereich funktioniert sofort ohne zusätzliche Anpassungen. Die Modelle mit log-Kopf sagen unbegrenzte Tiefen voraus und passen sich daher ohne Änderungen an Daten mit kurzer Reichweite (Makro) oder großer Reichweite (Außenbereich/Fahren) an. Durch das Setzen von max_depth: in deiner Dataset-YAML-Datei (in Metern) legst du fest, welche GT-Pixel bei den Validierungsmetriken berücksichtigt werden.
• Allgemeine Leistung erhalten. Wenn das Modell auch bei Szenen außerhalb deines Trainingsdatensatzes genau bleiben soll, mische einen kleinen Anteil (~5–10 %) vielfältiger, universell einsetzbarer Bilder in deine Trainingsdaten; dadurch wird das Vergessen während der Feinabstimmung deutlich reduziert.
• Nur von Grund auf trainieren (model=yolo26s-depth.yaml), wenn sich deine Domäne stark unterscheidet und du über einen großen Datensatz verfügst – in diesem Fall ist das standardmäßige SGD lr0=0.01 geeignet, da keine vortrainierten Gewichte erhalten werden müssen.

Tiefenskalierung kalibrieren#

Der Tiefenkopf trennt Form (relative Szenenstruktur) von der Skalierung (absolute Meter). Wenn ein Modell bereits eine gute relative Tiefe für deine Szenen erzeugt, die absoluten Werte für deine Kamera jedoch abweichen, kannst du die Skalierung mit model.calibrate() in wenigen Sekunden korrigieren – durch eine geschlossene Anpassung einer Log-Affinität mit zwei Parametern an einen kleinen beschrifteten Datensatz, ohne Gradienten-Training und ohne Änderung der Netzwerkgewichte. Dadurch kann die relative Struktur nicht beeinträchtigt werden.

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")

Für die Kalibrierung wird eine Ground-Truth-Tiefenkarte benötigt, an die angepasst werden kann. Daher läuft sie auf einem beschrifteten Split und kann nicht bei einer Inferenz ohne Referenzdaten erfolgen. Die Anpassung und Bewertung erfolgt auf denselben Pixeln, die von den Validierungsmetriken ausgewertet werden: GT-Werte bei oder über max_depth der Dataset-YAML (standardmäßig 100 m) werden ausgeschlossen. Verwende sie, wenn die relative Tiefe bereits gut ist und nur Maßstab oder Reichweite nicht stimmen. Wenn sich die relative Struktur selbst für deine Domäne ändern muss, führe stattdessen ein Fein-Tuning durch.

Das Training erledigt dies automatisch: Nachdem model.train(...) abgeschlossen ist, werden der beste und der letzte Checkpoint auf dem Validierungssatz kalibriert, sodass sie direkt Tiefenwerte im metrischen Maßstab ausgeben.

Die veröffentlichten yolo26*-depth.pt-Checkpoints enthalten diese Kalibrierung bereits. Sie wurden anhand der Validierungsmischung des Vortrainings angepasst. Es handelt sich um einen einzigen globalen Maßstab über alle Domänen hinweg. Für die genaueste absolute Tiefe bei einem bestimmten Kameramodell oder Szenentyp führst du model.calibrate() auf einem kleinen beschrifteten Split deiner eigenen Daten aus – dadurch wird die integrierte Anpassung ersetzt.

Datensatzformat#

Datensätze zur Tiefenschätzung ordnen jedem RGB-Bild eine skalierte uint16-Tiefen-PNG oder eine Gleitkomma-NPY-Tiefenkarte in Metern zu. PNG-Werte verwenden standardmäßig Millimeter; Datensätze mit einer anderen Konvention setzen depth_scale in ihrer YAML. Der Loader leitet den Pfad zur Tiefenkarte ab, indem er die Komponente images durch depth ersetzt. Dabei wird .png bevorzugt und auf .npy zurückgegriffen, wenn diese nicht vorhanden ist.

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

Beispielsweise wird ein Bild unter images/train/scene_001.jpg mit einer Tiefenkarte unter depth/train/scene_001.png verknüpft. Die vollständige Formatspezifikation findest du im Leitfaden zu Datensätzen für die Tiefenschätzung.

Validierung#

Validiere die Genauigkeit eines trainierten YOLO26n-depth-Modells auf einem Datensatz zur Tiefenschätzung. Übergib data explizit, damit die Validierung die vorgesehene Dataset-YAML verwendet. Die veröffentlichten Gewichte wurden mit imgsz=768 trainiert. Für die beste Genauigkeit solltest du daher in dieser Größe validieren und Vorhersagen erstellen.

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

Vorhersage#

Verwende ein trainiertes YOLO26n-depth-Modell, um Vorhersagen für Bilder zu erstellen.

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

Ausführliche Informationen zum Modus predict findest du auf der Seite Predict.

Ausgabe der Ergebnisse#

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

Task-spezifische Felder Results für alle Tasks findest du im Abschnitt Vorhersageergebnisse nach Task.

Tiefenkarte einfärben#

Die Roh-Tiefenkarte ist ein einkanaliges Gleitkomma-Array in Metern – nützlich für Berechnungen, aber direkt schwer zu lesen. Um daraus ein Farbbild zu erstellen, verwendest du den Helfer colorize_depth in ultralytics.utils.plotting. Dieser ordnet das Tiefen-Array (H, W) einem (H, W, 3)-BGR-uint8-Bild zu; ungültige Pixel <= 0 werden schwarz dargestellt.

result.plot() legt diese Einfärbung bereits mit den Standardwerten (cmap="jet", mode="disparity") über das Eingabebild. Rufe colorize_depth direkt auf, wenn du ein eigenständiges eingefärbtes Tiefenbild oder eine andere Farbkarte beziehungsweise Normalisierung möchtest.

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 zu warm/hell. mode legt fest, welches Ende der Farbskala die Nähe darstellt, während vmin/vmax den Wertebereich über mehrere Bilder hinweg festlegen, sodass eine Farbe immer dieselbe Entfernung bedeutet.

Export#

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

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")

Die verfügbaren Exportformate für die YOLO26-Tiefenschätzung sind in der folgenden Tabelle aufgeführt. Mit dem Argument format kannst du in jedes Format exportieren, beispielsweise mit format='onnx' oder format='engine'. Exportierte Modelle kannst du direkt für Vorhersagen oder Validierungen verwenden, beispielsweise mit yolo predict model=yolo26n-depth.onnx. Nach Abschluss des Exports werden Nutzungsbeispiele für dein Modell angezeigt.

nms=None verwendet standardmäßig Rohausgaben für externes NMS. Setze nms=False, um einen verfügbaren NMS-freien Kopf auszuwählen; nicht unterstützte Formate greifen auf ihren nativen Ausgabepfad zurück. Die Einträge nms oben identifizieren Formate, die NMS mit nms=True einbetten können.

Ausführliche Informationen zu export findest du auf der Seite Export.

FAQ#