Stima della profondità monoculare#

La stima della profondità monoculare predice una mappa di profondità per pixel da una singola immagine RGB. Ogni pixel di output contiene un valore di profondità in metri che rappresenta la distanza stimata dalla fotocamera a quel punto della superficie.

L'output di un modello di profondità è una mappa di float densa di forma (H, W) allineata all'immagine di input. Questa rappresentazione per pixel rende la stima della profondità monoculare particolarmente adatta per la ricostruzione di scene 3D, la navigazione dei robot, la creazione di contenuti AR/VR e qualsiasi applicazione che richieda una disposizione spaziale da una singola fotocamera.

Modelli#

I modelli di profondità YOLO26 preaddestrati su un ampio mix di dataset (interno + esterno, ~2,19 milioni di immagini) sono mostrati di seguito. Le colonne delle metriche sono riportate sul set di test Eigen di NYU Depth V2.

I Modelli vengono scaricati automaticamente dall'ultimo rilascio di Ultralytics al primo utilizzo.

• delta1^NYU è la percentuale di pixel in cui la profondità prevista rientra in un fattore di 1,25 rispetto alla verità di base, sullo split di test Eigen di NYU Depth V2 (654 immagini) con TTA multi-scala + ribaltamento orizzontale e allineamento log-least-squares.
• L'accuratezza a scala singola senza TTA è riproducibile con yolo depth val model=yolo26n-depth.pt data=nyu-depth.yaml imgsz=768 device=0 (sostituisci model= per ciascuna dimensione), che utilizza l'allineamento della mediana (solo scala) e ottiene punteggi inferiori: delta1 0.783 (n), 0.793 (s), 0.840 (m), 0.853 (l), 0.860 (x).
• abs_rel è l'errore relativo assoluto medio tra i valori di profondità previsti e quelli di verità di base.
• rmse è l'errore quadratico medio in metri.
• La velocità è la latenza relativa alla sola inferenza (pre/post-elaborazione esclusa) a imgsz=768, batch=1, riportata come media ± deviazione standard su esecuzioni temporizzate dopo il riscaldamento. CPU ONNX è ONNX Runtime fp32 su un Intel Xeon a 32 core (Skylake); T4 TensorRT10 è TensorRT fp16 su una Tesla T4.
• params e FLOPs sono misurati a 768×768, la risoluzione di addestramento dei pesi rilasciati.

Velocità rispetto a Depth Anything V2#

Depth Anything V2 è una baseline aperta ampiamente utilizzata per la profondità monoculare. Il suo backbone vision transformer DINOv2 e il decoder DPT sono pesanti dal punto di vista computazionale, quindi sulla stessa Tesla T4 con TensorRT fp16 il modello Depth Anything V2 rilasciato più piccolo è più lento di ogni modello di profondità YOLO26, incluso YOLO26x-depth, che trasporta più del doppio dei parametri.

A ~768 px — imgsz=768 per YOLO26, la risoluzione a cui sono addestrati i pesi rilasciati, e 770 px per Depth Anything V2, il cui backbone DINOv2 richiede un multiplo della dimensione della sua patch di 14:

A ~640 px — rispettivamente imgsz=640 e 644 px — l'ordinamento rimane invariato e YOLO26n-depth è 5,9 volte più veloce di Depth Anything V2 Small:

• La latenza è riferita alla sola inferenza, batch=1, TensorRT fp16 su una Tesla T4 — la stessa configurazione della tabella dei modelli sopra, mostrata qui con due decimali; gli FPS sono il reciproco della latenza non arrotondata. Le colonne Speedup dividono la latenza di Depth Anything V2 Small (20,99 ms) e Base (55,40 ms) per la latenza di YOLO26.
• Depth Anything V2 Small e Base sono i checkpoint ViT-S e ViT-B rilasciati.
• Il confronto copre solo la latenza: le due famiglie di modelli non vengono valutate qui secondo un protocollo di accuratezza condiviso.

Intervallo di profondità e head log-depth#

La testa di profondità predice exp(logit) — non vincolata (~0,02–150 m) — e separa la forma della scena dalla scala assoluta: la rete predice un campo di log-profondità relativo, e i metri assoluti vengono impostati da una trasformazione separata a due parametri (exp(a·log d + b)) recuperata durante la valutazione, mediante calibrazione leggera o tramite fine-tuning. La comune alternativa, una testa limitata sigmoid × max_depth, integra invece un limite fisso nell'architettura, per cui qualsiasi profondità oltre max_depth viene tagliata, impedendo l'addestramento e la predizione su scene a raggio più lungo.

Perché l'head non è limitato: evidenze su intervalli di profondità#

A/B test controllato — stessi dati, stesso programma, cambia solo l'head. Addestrando entrambi gli head da zero su un mix identico di dati interni (≤10 m) ed esterni (≤80 m):

La testa limitata non può rappresentare la maggioranza dei pixel esterni >10 m, quindi smette di migliorare quasi immediatamente; la testa log impara dall'intero intervallo.

La modalità di errore che corregge — fine-tuning su singolo set di dati, stratificato per intervallo. Il fine-tuning di un head limitato (10 m) su singoli set di dati funziona quando i dati rientrano nel limite e crolla quando lo superano:

Il collasso si verifica esattamente in corrispondenza del limite del tetto. La testa log non ha un tale limite.

Modelli rilasciati — prestazioni su vari intervalli. La famiglia con testa log spedita, valutata su benchmark che vanno da 10 m (NYU, iBims-1) a 80 m (KITTI), con δ1 allineato alla scala:

Entrambe le colonne sono come pubblicate. Le altre righe sono valutate con il protocollo TTA e log-least-squares descritto nelle relative pagine dei dataset, che il validatore in questo repository non implementa, quindi la riga KITTI non può essere misurata sulle stesse basi; la pagina KITTI riporta i numeri misurati sullo split canonico di 652 frame di Eigen.

I maggiori guadagni si registrano sui benchmark esterni a lungo raggio (KITTI, ETH3D) — esattamente dove un limite fisso di 10 m è più dannoso — mentre le prestazioni in interni vengono mantenute.

Addestramento#

Addestra YOLO26n-depth sul dataset Depth8 per 100 epoche con una dimensione dell'immagine di 640. Per un elenco completo degli argomenti disponibili, consulta la pagina Configurazione.

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)

Visualizza i dettagli completi della modalità train nella pagina Train.

Fine-tuning sui tuoi dati#

Quando adatti un modello di profondità preaddestrato a un dataset personalizzato, abbassa il tasso di apprendimento e usa l'ottimizzatore AdamW. Le impostazioni predefinite dell'ottimizzatore sono ottimizzate per l'addestramento da zero (SGD con lr0=0.01); applicate a un modello di profondità già convergente possono sovrascrivere la conoscenza preaddestrata e degradare i risultati, specialmente durante il fine-tuning su un singolo dominio.

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
)

Suggerimenti aggiuntivi:

• L'aumento dei dati è controllato dagli argomenti standard (degrees, translate, scale, shear, perspective, flipud, fliplr, hsv_h, hsv_s, hsv_v); la distorsione geometrica e i ribaltamenti vengono applicati in modo identico alla mappa di profondità associata. Per vedere la ricetta esatta utilizzata per i pesi YOLO26-Depth rilasciati, ispeziona il file train_args memorizzato nel checkpoint — vedi Ispezione degli argomenti di addestramento del checkpoint di YOLO26.
• mosaic, mixup, cutmix e copy_paste non sono implementati per la profondità. Il caricatore del dataset di profondità imposta automaticamente queste probabilità a 0, quindi il loro passaggio non ha alcun effetto. Queste modifiche non sono supportate perché combinano più immagini, il che produrrebbe mappe di profondità accoppiate non valide.
• Qualsiasi intervallo di profondità funziona immediatamente. I modelli con testa log predicono una profondità non vincolata, quindi si adattano a dati a corto raggio (macro) o a lungo raggio (esterni/guida) senza modifiche. Impostando max_depth: nel file YAML del tuo dataset (in metri) limiti quali pixel di ground truth contano per le metriche di validazione.
• Mantieni le prestazioni generali. Se hai bisogno che il modello rimanga accurato su scene oltre il tuo set di addestramento, mescola una piccola frazione (~5–10%) di immagini generiche diverse nei tuoi dati di addestramento; questo riduce sostanzialmente la perdita di memoria durante il fine-tuning.
• Addestra da zero (model=yolo26s-depth.yaml) solo se il tuo dominio è molto diverso e disponi di un ampio dataset; in quel caso l'SGD predefinito lr0=0.01 è appropriato, poiché non ci sono pesi preaddestrati da preservare.

Calibrazione della scala di profondità#

La testa di profondità separa la forma (struttura relativa della scena) dalla scala (metri assoluti). Se un modello produce già una buona profondità relativa sulle tue scene ma i valori assoluti sono errati per la tua fotocamera, puoi correggere la scala in pochi secondi con model.calibrate() — un adattamento in forma chiusa di una trasformazione log-affine a due parametri rispetto a un piccolo set etichettato, senza addestramento del gradiente e senza alcuna modifica ai pesi della rete, quindi non può degradare la struttura relativa.

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

La calibrazione richiede la profondità di ground truth a cui adattarsi, quindi viene eseguita su un set etichettato — non è qualcosa che può avvenire durante un'inferenza cieca. Si adatta e calcola il punteggio sugli stessi pixel valutati dalle metriche di validazione: la GT pari o superiore a max_depth del file YAML del dataset (predefinito 100 m) viene esclusa. Usala quando la profondità relativa è già buona e solo la scala/l'intervallo sono errati; se la struttura relativa stessa deve cambiare per il tuo dominio, effettua il fine-tuning anziché farlo.

L'addestramento lo fa automaticamente per te: al completamento di model.train(...), i checkpoint migliori e ultimi vengono calibrati sul set di validazione in modo da restituire nativamente una profondità scalata in metriche.

I checkpoint rilasciati di yolo26*-depth.pt vengono forniti con questa calibrazione già incorporata, adattata sul mix di validazione del preaddestramento. Si tratta di un'unica scala globale tra tutti i domini, quindi per ottenere la profondità assoluta più accurata su una specifica fotocamera o tipo di scena, esegui model.calibrate() su un piccolo set etichettato dai tuoi dati: questo sostituisce l'adattamento incorporato.

Formato del dataset#

I dataset per la stima della profondità associano a ogni immagine RGB un file di profondità corrispondente. I target di profondità sono memorizzati come array .npy contenenti valori float32 in metri. Il file YAML del dataset punta a una directory images/; il caricatore ricava il percorso del file di profondità sostituendo il componente images con depth e sostituendo l'estensione dell'immagine con .npy.

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

Ad esempio, un'immagine in images/train/scene_001.jpg è associata a una mappa di profondità in depth/train/scene_001.npy. Consulta la Guida al dataset di stima della profondità per la specifica completa del formato.

Valutazione#

Valida l'accuratezza di un modello YOLO26n-depth addestrato su un dataset di stima della profondità. Passa esplicitamente data in modo che la validazione utilizzi il file YAML del dataset previsto. I pesi rilasciati sono addestrati a imgsz=768, quindi valida ed esegui stime a quella dimensione per ottenere la massima accuratezza.

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

Previsione#

Usa un modello YOLO26n-depth addestrato per eseguire previsioni sulle immagini.

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

Visualizza i dettagli completi della modalità predict nella pagina Predict.

Output dei risultati#

La stima della profondità YOLO restituisce un oggetto Results per immagine. Ogni risultato memorizza una mappa di profondità densa in virgola mobile per l'intera immagine.

Per i campi specifici dell'attività Results relativi a ogni attività, consulta la sezione Risultati di predizione per attività.

Colorazione della mappa di profondità#

La mappa di profondità grezza è un array float a canale singolo in metri, utile per i calcoli ma difficile da leggere direttamente. Per trasformarla in un'immagine a colori, usa l'helper colorize_depth in ultralytics.utils.plotting, che mappa l'array di profondità (H, W) su un'immagine uint8 BGR (H, W, 3) (i pixel non validi <= 0 vengono resi in nero).

result.plot() fonde già questa colorazione sull'immagine di input utilizzando i valori predefiniti (cmap="jet", mode="disparity"); chiama direttamente colorize_depth quando desideri un'immagine di profondità colorata indipendente o una mappa di colori o normalizzazione diversa.

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

Ogni mappa di colori va da fredda/scura a calda/luminosa. L'mode determina quale estremità è vicina e vmin/vmax bloccano l'intervallo tra i fotogrammi in modo che un colore indichi sempre la stessa distanza.

Esportazione#

Esporta un modello YOLO26n-depth in un formato diverso come ONNX, CoreML, ecc.

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

I formati di esportazione disponibili per la stima della profondità YOLO26 sono elencati nella tabella sottostante. Puoi esportare in qualsiasi formato utilizzando l'argomento format, ad es. format='onnx' o format='engine'. Puoi effettuare previsioni o convalide direttamente sui modelli esportati, ad es. yolo predict model=yolo26n-depth.onnx. Gli esempi d'uso vengono mostrati per il tuo modello al termine dell'esportazione.

Visualizza i dettagli completi di export nella pagina Export.

FAQ#