Link to this sectionMonokulare 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 Float-Karte der Form (H, W), die auf das Eingabebild ausgerichtet ist. Diese pro-Pixel-Darstellung macht die monokulare Tiefenschätzung sehr gut geeignet für 3D-Szenenrekonstruktion, Roboternavigation, AR/VR-Content-Erstellung und jede Anwendung, die ein räumliches Layout von einer einzelnen Kamera benötigt.

Link to this sectionModelle#

YOLO26-Tiefenmodelle, die auf einer breiten Mischung von Datensätzen (innen + außen, ~2,19 Mio. Bilder) vortrainiert wurden, sind unten dargestellt. Die Metrikspalten beziehen sich auf den Eigen-Test-Split von NYU Depth V2.

Modelle werden bei der ersten Verwendung automatisch vom 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.
• Single-Scale-Genauigkeit ohne TTA ist reproduzierbar mit yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (ersetze model= für jede Größe), was eine mediane (nur Skalierung) Ausrichtung verwendet und niedriger punktet: delta1 0,785 (n), 0,786 (s), 0,827 (m), 0,839 (l), 0,843 (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.
• params und FLOPs werden bei 768×768 gemessen, der Trainingsauflösung der veröffentlichten Gewichte.

Link to this sectionTiefenbereich und der Log-Tiefen-Head#

Der Tiefen-Head sagt exp(logit) voraus — unbegrenzt (~0,02–150 m) — und entkoppelt die Szenenform vom absoluten Maßstab: Das Netzwerk sagt ein relatives Log-Tiefenfeld voraus, und absolute Meter werden durch eine separate Zwei-Parameter-Transformation (exp(a·log d + b)) bestimmt, die bei der Evaluierung, durch eine leichte Kalibrierung oder durch Feinabstimmung wiederhergestellt wird. Die übliche Alternative, ein begrenzter sigmoid × max_depth-Head, integriert stattdessen eine feste Obergrenze in die Architektur, sodass jede Tiefe über max_depth hinaus abgeschnitten wird — was das Training auf und die Vorhersage von länger reichenden Szenen verhindert.

Link to this sectionWarum 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 begrenzte Head kann den Großteil der Außenpixel (>10 m) nicht abbilden, daher hört er fast sofort auf, sich zu verbessern; der log-Head 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 findet genau an der Begrenzungsgrenze statt. Der log-Head hat keine solche Grenze.

Veröffentlichte Modelle — Bereichsübergreifende Leistung. Die ausgelieferte log-Head-Familie, evaluiert über Benchmarks von 10 m (NYU, iBims-1) bis 80 m (KITTI), mit skalen-ausgerichtetem δ1:

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.

Link to this sectionTrainieren#

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 Konfigurations-Seite.

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)

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

Link to this sectionFeinabstimmung auf eigenen Daten#

Wenn du ein vortrainiertes Tiefenmodell an einen benutzerdefinierten Datensatz anpasst, verringere die Lernrate und verwende den AdamW-Optimierer. Die Standard-Optimierereinstellungen sind für das Training von Grund auf optimiert (SGD mit lr0=0.01); angewendet auf ein bereits konvergiertes 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 Tipps:

• Die Augmentierung wird durch die Standard-Argumente gesteuert (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v); die geometrische Verzerrung und Spiegelungen werden identisch auf die gepaarte Tiefenkarte angewendet. Um das genaue Rezept zu sehen, das für die veröffentlichten YOLO26-Depth-Gewichte verwendet wurde, untersuche die im Checkpoint gespeicherten train_args — siehe Untersuchung der YOLO26 Checkpoint-Trainingsargumente.
• mosaic, mixup, cutmix und copy_paste sind für Tiefe nicht implementiert. Der Ladeprozess für Tiefendatensätze setzt diese Wahrscheinlichkeiten automatisch auf 0, daher hat ihre Übergabe keinen Effekt. Diese Augmentierungen werden nicht unterstützt, da sie mehrere Bilder kombinieren, was ungültige gepaarte Tiefenkarten erzeugen würde.
• Jeder Tiefenbereich funktioniert sofort. Die log-Head-Modelle sagen unbegrenzte Tiefe voraus, daher passen sie sich ohne Änderungen an kurzreichende (Makro) oder langreichende (Außenbereich/Fahren) Daten an. Das Festlegen von max_depth: in deinem Datensatz-YAML (in Metern) begrenzt, welche GT-Pixel zur Validierungsmetrik 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, wenn deine Domäne sehr unterschiedlich ist und du einen großen Datensatz hast — dort ist der Standard-SGD lr0=0.01 angemessen, da es keine vortrainierten Gewichte zu bewahren gibt.

Link to this sectionKalibrierung der Tiefenskala#

Der Tiefen-Head trennt Form (relative Szenenstruktur) von Skala (absolute Meter). Wenn ein Modell bereits eine gute relative Tiefe in deinen Szenen erzeugt, aber die absoluten Werte für deine Kamera falsch sind, kannst du die Skala in Sekunden mit model.calibrate() korrigieren — eine geschlossene Anpassung eines Zwei-Parameter-Log-Affins an einen kleinen beschrifteten Datensatz, ohne Gradiententraining und ohne Änderung der Netzwerkgewichte, sodass die relative Struktur nicht beeinträchtigt 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 zur Anpassung, daher läuft sie auf einem beschrifteten Split — sie kann nicht bei einer blinden Inferenz stattfinden. Verwende sie, wenn die relative Tiefe bereits gut ist und nur die Skala/der Bereich falsch ist; wenn sich die relative Struktur selbst für deine Domäne ändern muss, feinabstimmen stattdessen.

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

Die veröffentlichten yolo26*-depth.pt-Checkpoints werden bereits mit dieser Kalibrierung ausgeliefert, angepasst an den Pretraining-Validierungsmix. Es ist eine einzige globale Skala über alle Domänen hinweg, daher solltest du für die genaueste absolute Tiefe auf einer spezifischen Kamera oder einem Szenentyp model.calibrate() auf einem kleinen beschrifteten Split aus deinen eigenen Daten ausführen — dies ersetzt die integrierte Anpassung.

Link to this sectionDatensatzformat#

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

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

Zum Beispiel wird ein Bild unter images/train/scene_001.jpg mit einer Tiefenkarte unter depth/train/scene_001.npy gepaart. Siehe den Leitfaden für Tiefenschätzungs-Datensätze für die vollständige Formatspezifikation.

Link to this sectionValidieren#

Validiere die Genauigkeit eines trainierten YOLO26n-depth-Modells auf einem Tiefenschätzungs-Datensatz. Gib data explizit an, damit die Validierung das beabsichtigte Datensatz-YAML verwendet. Die veröffentlichten Gewichte sind bei imgsz=768 trainiert, also validiere und prognostiziere bei dieser Größe für die 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

Link to this sectionVorhersagen#

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

Siehe vollständige Details zum predict-Modus auf der Predict-Seite.

Link to this sectionErgebnisausgabe#

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

Für aufgaben-spezifische Results-Felder für jede Aufgabe siehe den Abschnitt Vorhersageergebnisse nach Aufgabe.

Link to this sectionExportieren#

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 YOLO26-Tiefenschätzungs-Exportformate sind in der folgenden Tabelle aufgeführt. Du kannst in jedes Format mit dem format-Argument exportieren, z. B. format='onnx' oder format='engine'. Du kannst direkt mit exportierten Modellen vorhersagen oder validieren, z. B. yolo predict model=yolo26n-depth.onnx. Anwendungsbeispiele werden für dein Modell nach Abschluss des Exports angezeigt.

Siehe vollständige export Details auf der Export Seite.

Link to this sectionFAQ#

Link to this sectionWie trainiere ich ein YOLO26 Tiefenschätzungsmodell auf einem benutzerdefinierten Datensatz?#

Bereite gepaarte RGB-Bilder und .npy-Tiefendateien vor und erstelle dann ein Datensatz-YAML, das auf dein images/-Verzeichnis verweist. Der Loader findet Tiefendateien automatisch, indem er images durch depth im Pfad ersetzt und die Bilddateiendung gegen .npy austauscht.

Starte mit vortrainierten Gewichten und verwende eine niedrige Lernrate mit AdamW, damit das Fine-Tuning beibehält, was das Modell bereits gelernt hat (siehe Fine-tuning on your own data für das Warum):

from ultralytics import YOLO

# Load a pretrained YOLO26 depth model
model = YOLO("yolo26s-depth.pt")

# Fine-tune on a custom depth dataset
results = model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,
    warmup_bias_lr=1e-4,
)

Besuche die Konfigurations Seite für weitere verfügbare Argumente.

Link to this sectionWelche Metriken liefert die YOLO26 Tiefenschätzung?#

Die Validierung der Tiefenschätzung liefert den Metriksatz, der von Depth Anything und verwandten monokularen Tiefenarbeiten verwendet wird:

• delta1 / delta2 / delta3 — Prozentsatz der Pixel, bei denen das Verhältnis der vorhergesagten zur Ground-Truth-Tiefe (oder deren Kehrwert) unter 1.25, 1.25² bzw. 1.25³ liegt. Höher ist besser.
• abs_rel — mittlerer absoluter relativer Fehler. Niedriger ist besser.
• rmse — Wurzel aus dem mittleren quadratischen Fehler in Metern. Niedriger ist besser.
• silog — skaleninvarianter logarithmischer Fehler. Niedriger ist besser.

Jede Vorhersage wird pro Bild median-aligniert zu ihrer Ground Truth, und die Statistiken werden dann über jedes gültige Pixel des Validierungssets aggregiert (Bilder mit mehr gültigen Tiefenpixeln werden proportional stärker gewichtet). Arbeiten, die stattdessen Metriken pro Bild mitteln, können leicht unterschiedliche Werte für dieselben Vorhersagen berichten.

Link to this sectionWas ist das Ausgabeformat der Tiefenkarte?#

Die Tiefenkarte wird als torch.Tensor der Form (H, W) gespeichert, wobei jeder Wert die vorhergesagte Tiefe in Metern ist (verwende result.depth.data.cpu().numpy() für ein NumPy float32-Array). Greife über result.depth.data darauf zu, nachdem du die Vorhersage ausgeführt hast. Die Karte ist auf die Auflösung des Eingabebildes ausgerichtet.

Link to this sectionWelche Datensätze werden für die Tiefenschätzung unterstützt?#

Ultralytics YOLO26 bietet integrierte Datensatz-YAML-Konfigurationen für verschiedene Tiefenschätzungs-Datensätze, darunter NYU Depth V2, KITTI, Hypersim, SUN RGB-D und ARKitScenes. Siehe den Depth Estimation Dataset Guide für die vollständige Liste und Formatdetails.

Link to this sectionWie validiere ich ein vortrainiertes YOLO26 Tiefenschätzungsmodell?#

Validiere ein vortrainiertes YOLO26 Tiefenmodell, indem du das für die Evaluierung verwendete Datensatz-YAML bereitstellst:

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n-depth.pt")

# Validate the model
metrics = model.val(data="nyu-depth.yaml")
print("delta1:", metrics.delta1)
print("abs_rel:", metrics.abs_rel)
print("rmse:", metrics.rmse)

Link to this sectionWie kann ich ein YOLO26 Tiefenschätzungsmodell in das ONNX-Format exportieren?#

Exportiere ein YOLO26 Tiefenmodell mit Python oder CLI nach ONNX:

from ultralytics import YOLO

# Load a pretrained model
model = YOLO("yolo26n-depth.pt")

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

Weitere Details zum Exportieren in verschiedene Formate findest du auf der Export Seite.