Ultralytics YOLO ile Monoküler Derinlik Tahmini#

Monoküler derinlik tahmini, tek bir RGB görüntüsünden piksel başına bir derinlik haritası tahmin eder. Çıktıdaki her piksel, kameradan ilgili yüzey noktasına olan tahmini mesafeyi metre cinsinden gösteren bir derinlik değeri taşır.

Derinlik modelinin çıktısı, giriş görüntüsüyle hizalanmış (H, W) şekline sahip yoğun bir kayan nokta haritasıdır. Bu piksel başına gösterim, monoküler derinlik tahminini 3B sahne yeniden oluşturma, robot navigasyonu, AR/VR içerik üretimi ve tek bir kameradan uzamsal düzen gerektiren tüm uygulamalar için uygun hâle getirir.

Modeller#

Geniş ve çoklu veri kümesi karışımıyla (iç mekân + dış mekân, ~2.19M görüntü) önceden eğitilmiş YOLO26 derinlik modelleri aşağıda gösterilmiştir. Metrik sütunları NYU Depth V2 Eigen test bölümünde raporlanmıştır.

Modeller ilk kullanımda en güncel Ultralytics sürümünden otomatik olarak indirilir.

• delta1^NYU, çok ölçekli + yatay çevirme TTA ve log-en küçük kareler hizalamasıyla NYU Depth V2 Eigen test bölümünde (654 görüntü), tahmin edilen derinliğin gerçek değerin 1,25 katı aralığında olduğu piksellerin oranıdır.
• TTA olmadan tek ölçekli doğruluk, ölçeklerin her biri için model= kullanılarak yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 ile tekrarlanabilir; bu yöntem medyan (yalnızca ölçek) hizalaması kullanır ve daha düşük skor verir: delta1 0.783 (n), 0.793 (s), 0.840 (m), 0.853 (l), 0.860 (x).
• abs_rel, tahmin edilen ve gerçek derinlik değerleri arasındaki ortalama mutlak bağıl hatadır.
• rmse, metre cinsinden kök ortalama kare hatadır.
• Hız, imgsz=768, batch=1 çözünürlüğünde, ısınma sonrasındaki zamanlanmış çalıştırmaların ortalaması ± std olarak raporlanan yalnızca çıkarım gecikmesidir (ön/son işleme dâhil değildir). CPU ONNX, 32 çekirdekli Intel Xeon (Skylake) üzerinde ONNX Runtime fp32'dir; T4 TensorRT10, Tesla T4 üzerinde TensorRT fp16'dır.
• parametreler ve FLOPs, yayımlanan ağırlıkların eğitim çözünürlüğü olan 768×768'de ölçülmüştür.

Ön NYU Depth V2 sonuçları için yayımlanmamış YOLO27 önizlemesine bak.

Depth Anything V2 ile hız karşılaştırması#

Depth Anything V2, monoküler derinlik için yaygın olarak kullanılan açık bir temel modeldir. DINOv2 görsel Transformer omurgası ve DPT kod çözücüsü yoğun hesaplama gerektirir. Bu nedenle aynı Tesla T4 üzerinde TensorRT fp16 kullanıldığında, yayımlanmış en küçük Depth Anything V2 modeli, iki kattan fazla parametreye sahip YOLO26x-depth dâhil tüm YOLO26 derinlik modellerinden daha yavaştır.

~768 pikselde — YOLO26 için imgsz=768 (yayımlanan ağırlıklarının eğitildiği çözünürlük) ve Depth Anything V2 için 770 piksel (DINOv2 omurgası, yama boyutu olan 14'ün katını gerektirir):

~640 pikselde — sırasıyla imgsz=640 ve 644 pikselde — sıralama değişmez ve YOLO26n-depth, Depth Anything V2 Small'dan 5.9× daha hızlıdır:

• Gecikme yalnızca çıkarımı kapsar; batch=1, Tesla T4 üzerinde TensorRT fp16 kullanır ve yukarıdaki model tablosundakiyle aynı test düzeneğiyle iki ondalık basamakla gösterilmiştir; FPS, yuvarlanmamış gecikmenin tersidir. Hızlanma sütunları, Depth Anything V2 Small (20.99 ms) ve Base (55.40 ms) gecikmelerini YOLO26 gecikmesine böler.
• Depth Anything V2 Small ve Base, yayımlanmış ViT-S ve ViT-B kontrol noktalarıdır.
• Karşılaştırma yalnızca gecikmeyi kapsar; iki model ailesi burada ortak bir doğruluk protokolüyle değerlendirilmemiştir.

Derinlik aralığı ve log-derinlik başlığı#

Derinlik başlığı exp(logit) tahmin eder — sınırsız (~0.02–150 m) — ve sahne şeklini mutlak ölçekten ayırır: ağ göreli bir log-derinlik alanı tahmin eder; mutlak metre değerleri ise değerlendirme sırasında, hafif kalibrasyonla veya ince ayarla elde edilen ayrı iki parametreli bir dönüşümle (exp(a·log d + b)) belirlenir. Yaygın alternatif olan sınırlı sigmoid × max_depth başlığı, bunun yerine mimariye sabit bir üst sınır yerleştirir; dolayısıyla max_depth değerini aşan tüm derinlikler kırpılır ve bu da daha uzun menzilli sahneler üzerinde eğitim yapmayı ve bu sahneleri tahmin etmeyi engeller.

Kontrollü A/B — aynı veri, aynı zaman çizelgesi, yalnızca başlık farklı. Her iki başlığı da aynı iç mekân (≤10 m) ve dış mekân (≤80 m) veri karışımıyla sıfırdan eğitmek:

Sınırlı başlık, dış mekân piksellerinin çoğunluğunu oluşturan >10 m aralığını temsil edemez; bu nedenle iyileşmesi neredeyse hemen durur. log başlığı ise tüm aralıktan öğrenir.

Çözdüğü başarısızlık biçimi — aralığa göre katmanlandırılmış tek veri kümesi ince ayarı. Sınırlı (10 m) bir başlıkta ayrı veri kümeleriyle yapılan ince ayar, veriler üst sınıra uyduğunda işe yarar; bu sınır aşıldığında ise performans çöker:

Çöküş tam olarak üst sınır noktasında gerçekleşir. log başlığında böyle bir sınır yoktur.

Yayımlanan modeller — aralıklar arası performans. Yayımlanan log başlıklı model ailesinin, 10 m (NYU, iBims-1) ile 80 m (KITTI) aralığını kapsayan kıyaslamalardaki ölçek hizalamalı δ1 sonuçları:

Her iki sütundaki değerler yayımlandıkları hâliyle verilmiştir. Diğer satırlar, bu depodaki doğrulayıcının uygulamadığı ve veri kümesi sayfalarında açıklanan TTA ve log-en küçük kareler protokolüyle puanlanmıştır; bu nedenle KITTI satırı aynı koşullarda yeniden ölçülemez. KITTI sayfasında bunun yerine standart 652 karelik Eigen bölümünde ölçülen değerler yer alır.

En büyük kazanımlar, sabit 10 m üst sınırının en çok zarar verdiği uzun menzilli dış mekân kıyaslamalarında (KITTI, ETH3D) elde edilir; iç mekân performansı ise korunur.

Eğit#

YOLO26n-depth modelini Depth8 veri kümesinde, görüntü boyutu 640 olacak şekilde 100 epoch boyunca eğit. Kullanılabilir bağımsız değişkenlerin tam listesi için Yapılandırma sayfasına bak.

from ultralytics import YOLO

# Bir model yükle
model = YOLO("yolo26n-depth.yaml")  # YAML'den yeni bir model oluştur
model = YOLO("yolo26n-depth.pt")  # Önceden eğitilmiş bir model yükle (eğitim için önerilir)
model = YOLO("yolo26n-depth.yaml").load("yolo26n-depth.pt")  # YAML'den oluştur ve ağırlıkları aktar

# Modeli eğit
results = model.train(data="depth8.yaml", epochs=100, imgsz=640)

train modu hakkında tüm ayrıntılar için Eğitim sayfasına bak. Derinlik modelleri Ultralytics Platform bulut eğitimi ile de eğitilebilir.

Veri kümesi biçimi#

Derinlik tahmini veri kümelerinde her RGB görüntü, metre cinsinden ölçeklenmiş bir uint16 derinlik PNG'siyle veya kayan noktalı NPY derinlik haritasıyla eşleştirilir. PNG değerleri varsayılan olarak milimetre cinsindendir; başka bir gösterim kullanan veri kümeleri YAML dosyalarında depth_scale ayarını yapar. Yükleyici, images bileşenini depth ile değiştirerek derinlik dosyasının yolunu türetir; önce .png öğesini tercih eder, bulunmazsa .npy öğesini kullanır.

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

Örneğin, images/train/scene_001.jpg yolundaki bir görüntü depth/train/scene_001.png yolundaki bir derinlik haritasıyla eşleştirilir. Biçim belirtiminin tamamı için Derinlik Tahmini Veri Kümesi Kılavuzu sayfasına bak.

Kendi verilerinle ince ayar#

Önceden eğitilmiş bir derinlik modelini özel bir veri kümesine uyarlarken öğrenme oranını düşür ve AdamW optimizer'ını kullan. Varsayılan optimizer ayarları sıfırdan eğitim için yapılandırılmıştır; zaten yakınsamış bir derinlik modeline uygulandıklarında önceden öğrenilmiş bilgiyi silebilir ve sonuçları kötüleştirebilirler. Bu etki özellikle tek bir alanda ince ayar yaparken belirgindir.

from ultralytics import YOLO

model = YOLO("yolo26s-depth.pt")  # önceden eğitilmiş ağırlıklarla başla

model.train(
    data="path/to/your_dataset.yaml",
    epochs=20,
    imgsz=640,
    optimizer="AdamW",
    lr0=1e-4,  # sıfırdan eğitim varsayılanının ~100 kat altında
    warmup_bias_lr=1e-4,  # ısınmayı da yumuşak tut
)

Ek ipuçları:

• Artırma, standart argümanlarla kontrol edilir (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v); geometrik çarpıtma ve çevirmeler eşleştirilmiş derinlik haritasına da aynı şekilde uygulanır. Yayınlanan YOLO26-Depth ağırlıkları için kullanılan tam tarifi görmek üzere kontrol noktasında kayıtlı train_args değerini incele — YOLO26 Kontrol Noktası Eğitim Argümanlarını İnceleme sayfasına bak.
• Derinlik için mosaic, mixup, cutmix ve copy_paste uygulanmamıştır. Derinlik veri kümesi yükleyicisi bu olasılıkları otomatik olarak 0'a ayarlar; bu nedenle bunları geçirmenin etkisi olmaz. Bu artırmalar birden fazla görüntüyü birleştirdiğinden ve bu da eşleştirilmiş derinlik haritalarını geçersiz kılacağından desteklenmez.
• Her derinlik aralığı kutudan çıktığı gibi çalışır. log başlıklı modeller sınırsız derinlik tahmin eder; böylece kısa menzilli (makro) veya uzun menzilli (dış mekân/sürüş) verilere değişiklik yapmadan uyum sağlar. Veri kümesi YAML dosyanda max_depth: değerini ayarlamak, doğrulama metriklerine hangi GT piksellerinin dahil edileceğini (metre cinsinden) sınırlar.
• Genel performansı koru. Modelin eğitim kümenin dışındaki sahnelerde de doğru sonuç vermesini istiyorsan eğitim verilerine çeşitli, genel amaçlı görüntülerden küçük bir oran (~5–10%) ekle; bu, ince ayar sırasında unutmayı önemli ölçüde azaltır.
• Sıfırdan eğitimi (model=yolo26s-depth.yaml) yalnızca alanın çok farklıysa ve büyük bir veri kümen varsa kullan — bu durumda, korunacak önceden eğitilmiş ağırlıklar olmadığından varsayılan optimizer=auto uygundur.

Derinlik ölçeğini kalibre etme#

Derinlik başlığı şekli (sahnenin göreli yapısı) ölçekten (mutlak metre) ayırır. Model sahnelerinde zaten iyi göreli derinlik üretiyor ancak mutlak değerler kamerana göre hatalıysa, küçük bir etiketli kümede başlığın log-affine dönüşümüne kapalı biçimli, yalnızca ölçeğe yönelik bir uyum sağlayan model.calibrate() ile ölçeği saniyeler içinde düzeltebilirsin. Bu uyum, yalnızca çapraz doğrulamalı elde tutulan δ1 değerini iyileştirdiğinde korunur; gradyan eğitimi yapılmaz ve ağ ağırlıkları değiştirilmez, dolayısıyla göreli yapı kötüleşemez.

from ultralytics import YOLO

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

# Etiketli bir bölümde ölçeği uydur (yaklaşık 100+ görüntü yeterli), ardından kalibrasyonu kaydet
model.calibrate(data="path/to/your_dataset.yaml")
model.save("yolo26s-depth-calibrated.pt")

Kalibrasyon için uyum sağlanacak gerçek derinlik değerleri gerekir; bu nedenle etiketli bir bölümde çalışır — kör çıkarım sırasında yapılamaz. Uyum ve puanlama, doğrulama metriklerinin değerlendirdiği piksellerle yapılır: veri kümesi YAML dosyasındaki max_depth değerine eşit veya daha büyük GT (varsayılan 100 m) hariç tutulur. Göreli derinlik zaten iyiyse ve yalnızca ölçek/aralık hatalıysa bunu kullan; alanın için göreli yapının kendisinin değişmesi gerekiyorsa bunun yerine ince ayar yap.

Eğitim bunu senin için otomatik olarak yapar: model.train(...) tamamlandıktan sonra en iyi ve son kontrol noktaları doğrulama kümesinde kalibre edilir; böylece kutudan çıktığı gibi metrik ölçekli derinlik üretirler.

Yayınlanan yolo26*-depth.pt kontrol noktaları bu kalibrasyon uygulanmış olarak gelir; kalibrasyon, ön eğitim doğrulama karışımında uydurulmuştur. Tüm alanlarda tek bir genel ölçek kullanılır; bu nedenle belirli bir kamera veya sahne türünde en doğru mutlak derinliği elde etmek için kendi verilerinden küçük, etiketli bir bölümde model.calibrate() çalıştır — bu, önceden uygulanmış uyumun yerini alır.

Derinlik kamerası olmadan gerçek referans derinlik elde etme#

Kameranda derinlik sensörü olmasa bile kalibrasyon yapabilirsin. Kalibrasyon, tek bir global ölçek uydurur ve derinliği 0 olan pikselleri yok sayar; bu nedenle görüntü başına ölçülmüş birkaç nokta yeterlidir.

1. Görüntüleri topla. Kameranı kullanacağın çözünürlük ve lens ayarlarında 50 ila 150 görüntü çek ve bunları dataset/images/val/ içine koy. Kalibrasyon, val bölümünü okur.

2. Derinliği etiketle. Aşağıdaki iki yöntemden birini kullan. Her ikisi de veri kümesi biçiminde her görüntü için dataset/depth/val/ içine bir derinlik haritası yazar.

image,x,y,meters
img_0001.jpg,352,453,3.15
img_0001.jpg,28,300,2.672

import csv
from collections import defaultdict
from pathlib import Path

import cv2
import numpy as np

points = defaultdict(list)
with open("points.csv") as f:  # columns: image, x, y, meters
    for row in csv.DictReader(f):
        points[row["image"]].append((int(row["x"]), int(row["y"]), float(row["meters"])))

for name, pts in points.items():
    h, w = cv2.imread(f"dataset/images/val/{name}").shape[:2]
    depth = np.zeros((h, w), np.uint16)  # 0 means no label
    r = max(h, w) // 768 + 1  # dot radius that survives the resize to imgsz=768
    for x, y, meters in pts:
        cv2.circle(depth, (x, y), r, round(meters * 100), -1)  # centimeters, matching depth_scale: 100
    out = Path("dataset/depth/val") / f"{Path(name).stem}.png"
    out.parent.mkdir(parents=True, exist_ok=True)
    cv2.imwrite(str(out), depth)

3. Veri kümesi YAML dosyasını calib.yaml olarak yaz. depth_scale: 100, ölçülen noktalardan elde edilen santimetre cinsinden PNG'leri okur ve NPY haritaları için yok sayılır:

   path: dataset
   train: images/val
   val: images/val
   depth_scale: 100 # PNG value 100 = 1 meter
   names:
       0: depth

4. Kalibrasyonu yap ve kaydet, ardından tahmin veya dışa aktarma için yolo26s-depth-calibrated.pt yükle:

   from ultralytics import YOLO
   
   model = YOLO("yolo26s-depth.pt")
   model.calibrate(data="calib.yaml", imgsz=768)
   model.save("yolo26s-depth-calibrated.pt")

yolo26s-depth.pt ve kamera başına 150 görüntüyle yapılan testlerde, yayımlanan kalibrasyon NYU, KITTI ve dar lensli bir kamera için tam gerçek referans verilerine uydurulan ölçekten %4 ila %46 sapma gösterdi. Görüntü başına 5 ölçülmüş noktayla kalibrasyon, bu uyumun %1 yakınına ulaştı; DA3METRIC-LARGE etiketleriyle yapılan kalibrasyon ise %7 yakınına ulaştı. Daha fazla görüntü, görüntü başına daha fazla noktadan daha çok fayda sağlar: Görüntü başına 1 nokta kullanılan 150 görüntü yaklaşık %3 içinde kalırken, görüntü başına 5 nokta kullanılan 20 görüntüde sapma %9'a kadar çıktı.

Doğrula#

Eğitilmiş bir YOLO26n-depth modelinin doğruluğunu bir derinlik kestirimi veri kümesinde doğrula. Doğrulamada amaçlanan veri kümesi YAML dosyasının kullanılması için data değerini açıkça belirt. Yayımlanan ağırlıklar, dolguyla letterbox uygulanmış görüntüler yerine kare olacak şekilde esnetilmiş görüntüler üzerinde imgsz=768 boyutunda eğitildi; bu nedenle en iyi doğruluk için doğrulama ve tahmin işlemlerini bu boyutta yap. Tahmin, doğrulama ve model.calibrate() girdiyi aynı şekilde esnetir.

from ultralytics import YOLO

# Bir model yükle
model = YOLO("yolo26n-depth.pt")  # Resmî bir modeli yükle
model = YOLO("path/to/best.pt")  # özel bir model yükle

# Modeli doğrula
metrics = model.val(data="nyu-depth.yaml")
metrics.delta1  # eşik δ=1.25 içindeki piksel oranı
metrics.abs_rel  # ortalama mutlak göreli hata
metrics.rmse  # kök ortalama kare hata (metre)
metrics.silog  # ölçekten bağımsız logaritmik hata

Tahmin#

Görüntülerde tahmin yapmak için eğitilmiş bir YOLO26n-depth modeli kullan.

from ultralytics import YOLO

# Bir model yükle
model = YOLO("yolo26n-depth.pt")  # Resmî bir modeli yükle
model = YOLO("path/to/best.pt")  # özel bir model yükle

# Modelle tahmin yap
results = model("https://ultralytics.com/images/bus.jpg")  # bir görüntü üzerinde tahmin yap

# Sonuçlara eriş
for result in results:
    depth_map = result.depth.data.cpu().numpy()  # torch.Tensor -> NumPy float32, şekil (H, W), metre

predict kipinin tüm ayrıntıları için Tahmin sayfasına bak.

Sonuç Çıktısı#

YOLO derinlik kestirimi, görüntü başına bir Results nesnesi döndürür. Her sonuç, görüntünün tamamına ait yoğun bir kayan noktalı derinlik haritası içerir.

Tüm görevlerde göreve özgü Results alanları için Göreve Göre Tahmin Sonuçları bölümüne bak.

Örnek bölütlemeyle nesne başına derinlik#

Algılanan her nesnenin ne kadar uzakta olduğunu tahmin etmek için örnek bölütlemeyi derinlikle birleştir. Maskelerin derinlik haritasının özgün görüntü çözünürlüğünü paylaşması için her iki modeli de aynı görüntüde retina_masks=True ile çalıştır, ardından her maskenin içindeki geçerli derinlik piksellerinin medyanını al.

from ultralytics import YOLO

image = "https://ultralytics.com/images/bus.jpg"
seg = YOLO("yolo26n-seg.pt")(image, retina_masks=True)[0]
depth = YOLO("yolo26n-depth.pt")(image)[0].depth.data  # (H, W) meters

if seg.masks is not None:
    for mask, cls in zip(seg.masks.data.bool(), seg.boxes.cls):
        values = depth[mask & (depth > 0)]  # valid depth pixels inside this mask
        if values.numel():
            print(f"{seg.names[int(cls)]}: {values.median():.2f} m")

Medyan, maske kenarlarındaki arka plan piksellerinden etkilenmez; ancak nesnenin merkezini değil, görünen yüzeyini tanımlar ve doğruluğu modelin derinlik ölçeğine bağlıdır (Derinlik ölçeğini kalibre etme bölümüne bak).

Derinlik haritasını renklendirme#

Ham derinlik haritası metre cinsinden tek kanallı bir kayan noktalı dizidir; hesaplama için kullanışlıdır ancak doğrudan okunması zordur. Bunu renkli bir görüntüye dönüştürmek için ultralytics.utils.plotting içindeki colorize_depth yardımcı işlevini kullan. Bu işlev, (H, W) derinlik dizisini (H, W, 3) BGR uint8 görüntüsüne dönüştürür (geçersiz pikseller <= 0 siyah gösterilir).

result.plot(), bu renklendirmeyi varsayılan ayarlarla (cmap="jet", mode="disparity") giriş görüntüsünün üzerine zaten uygular; bağımsız bir renkli derinlik görüntüsü veya farklı bir renk haritası ya da normalizasyon istediğinde doğrudan colorize_depth çağır.

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

# Yakını sıcak tonlarla renklendir ve kaydet
cv2.imwrite("depth_colored.png", colorize_depth(depth, cmap="spectral"))  # (H, W, 3) BGR uint8

# Kareler arasında aynı rengin aynı mesafeyi göstermesi için aralığı 0-20 m olarak sabitle
cv2.imwrite("depth_metric.png", colorize_depth(depth, vmin=0.0, vmax=20.0, cmap="inferno", mode="metric"))

# Doğrudan Results nesnesinden harmanlanmış katman (cmap="jet", mode="disparity" kullanır)
result.save("depth_overlay.png")

Her renk haritası soğuk/koyu → sıcak/parlak yönünde ilerler. mode hangi ucun yakını göstereceğini belirler; vmin/vmax ise renklerin her zaman aynı mesafeyi göstermesi için kareler arasındaki aralığı sabitler.

Dışa aktar#

YOLO26n-depth modelini ONNX, CoreML vb. başka bir biçime aktar

from ultralytics import YOLO

# Bir model yükle
model = YOLO("yolo26n-depth.pt")  # Resmî bir modeli yükle
model = YOLO("path/to/best.pt")  # özel bir model yükle

# Modeli dışa aktar
model.export(format="onnx")

Kullanılabilir YOLO26 derinlik kestirimi dışa aktarma biçimleri aşağıdaki tabloda listelenmiştir. format argümanını, yani format='onnx' veya format='engine' değerini kullanarak istediğin biçime aktarabilirsin. Dışa aktarılmış modellerde doğrudan tahmin veya doğrulama yapabilirsin; örneğin yolo predict model=yolo26n-depth.onnx. Dışa aktarma tamamlandığında modeline ilişkin kullanım örnekleri gösterilir.

nms=None, harici NMS için varsayılan olarak ham çıktılar üretir. Kullanılabilir bir NMS içermeyen başlık seçmek için nms=False değerini ayarla; desteklenmeyen biçimler yerel çıktı yoluna döner. Yukarıdaki nms girdileri, nms=True ile NMS içerebilen biçimleri tanımlar.

Ayrıntılı export bilgileri için Dışa Aktarma sayfasına bak.

Sık Sorulan Sorular#