Link to this sectionStima 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 float densa di forma (H, W) allineata all'immagine di input. Questa rappresentazione per pixel rende la stima della profondità monoculare adatta alla ricostruzione di scene 3D, alla navigazione robotica, alla creazione di contenuti AR/VR e a qualsiasi applicazione che richieda la disposizione spaziale da una singola fotocamera.

Link to this sectionModelli#

I modelli YOLO26 depth pre-addestrati su un ampio mix di set di dati (interni + esterni, ~2,19M di immagini) sono mostrati di seguito. Le colonne delle metriche sono riportate sullo split di test Eigen di NYU Depth V2.

I modelli vengono scaricati automaticamente dall'ultima release 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 ogni dimensione), che utilizza l'allineamento mediano (solo scala) e ottiene punteggi inferiori: delta1 0,785 (n), 0,786 (s), 0,827 (m), 0,839 (l), 0,843 (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.
• params e FLOPs sono misurati a 768×768, la risoluzione di addestramento dei pesi rilasciati.

Link to this sectionIntervallo di profondità e head log-depth#

L'head di profondità predice exp(logit) — non limitato (~0,02–150 m) — e disaccoppia 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 in fase di valutazione, tramite calibrazione leggera o fine-tuning. L'alternativa comune, un head sigmoid × max_depth limitato, impone invece un limite fisso nell'architettura, quindi qualsiasi profondità oltre max_depth viene troncata — il che impedisce l'addestramento e la previsione di scene a lungo raggio.

Link to this sectionPerché 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):

L'head limitato non può rappresentare la maggioranza dei pixel esterni >10 m, quindi smette di migliorare quasi subito; l'head 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 crollo avviene esattamente al limite del cap. L'head log non ha tale limite.

Modelli rilasciati — prestazioni su vari intervalli. La famiglia di modelli log-head distribuita, valutata su benchmark che spaziano da 10 m (NYU, iBims-1) a 80 m (KITTI), con δ1 scalato-allineato:

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.

Link to this sectionAddestramento#

Addestra YOLO26n-depth sul set di dati Depth8 per 100 epoche con dimensione immagine 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)

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

Link to this sectionFine-tuning sui tuoi dati#

When adapting a pretrained depth model to a custom dataset, lower the learning rate and use the AdamW optimizer. The default optimizer settings are tuned for training from scratch (SGD with lr0=0.01); applied to an already-converged depth model they can overwrite the pretrained knowledge and degrade results — especially when fine-tuning on a single domain.

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 deformazione geometrica e i ribaltamenti vengono applicati in modo identico alla mappa di profondità accoppiata. Per vedere la ricetta esatta utilizzata per i pesi YOLO26-Depth rilasciati, ispeziona i train_args memorizzati nel checkpoint — vedi Ispezionare gli argomenti di addestramento dei checkpoint YOLO26.
• mosaic, mixup, cutmix e copy_paste non sono implementati per la profondità. Il caricatore del set di dati di profondità imposta automaticamente queste probabilità a 0, quindi passarle non ha effetto. Queste tecniche di aumento non sono supportate perché combinano più immagini, il che produrrebbe mappe di profondità accoppiate non valide.
• Qualsiasi intervallo di profondità funziona immediatamente. I modelli log-head predicono profondità non limitate, quindi si adattano a dati a corto raggio (macro) o lungo raggio (esterni/guida) senza modifiche. L'impostazione di max_depth: nel tuo YAML del set di dati (in metri) delimita quali pixel della GT 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.
• Train from scratch (model=yolo26s-depth.yaml) only if your domain is very different and you have a large dataset — there the default SGD lr0=0.01 is appropriate, since there are no pretrained weights to preserve.

Link to this sectionCalibrazione della scala di profondità#

L'head 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 non sono corretti 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 su un piccolo set etichettato, senza addestramento del gradiente e senza modifiche 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 una profondità di verità di base su cui adattarsi, quindi viene eseguita su uno split etichettato — non è qualcosa che può accadere durante l'inferenza cieca. Usala quando la profondità relativa è già buona e solo la scala/intervallo è errato; se la struttura relativa stessa deve cambiare per il tuo dominio, esegui invece il fine-tuning.

L'addestramento lo fa automaticamente per te: dopo il completamento di model.train(...), i checkpoint migliori e ultimi vengono calibrati sul set di validazione in modo che emettano profondità scalata metricamente senza configurazioni aggiuntive.

I checkpoint yolo26*-depth.pt rilasciati vengono forniti con questa calibrazione già integrata, adattata sul mix di pre-addestramento di validazione. È una scala globale singola su tutti i domini, quindi per la profondità assoluta più accurata su una fotocamera o un tipo di scena specifico, esegui model.calibrate() su un piccolo split etichettato dai tuoi dati — sostituisce l'adattamento integrato.

Link to this sectionFormato del dataset#

I set di dati per la stima della profondità accoppiano ogni immagine RGB con un file di profondità corrispondente. I target di profondità sono memorizzati come array .npy contenenti valori float32 in metri. Il YAML del set di dati punta a una directory images/; il caricatore deriva 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 è accoppiata con una mappa di profondità in depth/train/scene_001.npy. Vedi la Guida al set di dati di stima della profondità per la specifica completa del formato.

Link to this sectionValutazione#

Valida l' accuratezza di un modello YOLO26n-depth addestrato su un set di dati di stima della profondità. Passa data esplicitamente in modo che la validazione utilizzi il YAML del set di dati previsto. I pesi rilasciati sono addestrati a imgsz=768, quindi valida e predici a quella dimensione per la migliore 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

Link to this sectionPrevisione#

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

Vedi tutti i dettagli della modalità predict nella pagina Predict.

Link to this sectionOutput dei risultati#

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

Per i campi Results specifici per ogni attività, vedi la sezione Predizioni dei Risultati per Attività.

Link to this sectionEsportazione#

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 nella tabella sottostante. Puoi esportare in qualsiasi formato usando l'argomento format, ad esempio format='onnx' o format='engine'. Puoi predire o validare direttamente sui modelli esportati, ad esempio yolo predict model=yolo26n-depth.onnx. Esempi di utilizzo vengono mostrati per il tuo modello dopo il completamento dell'esportazione.

Vedi i dettagli completi dell'export nella pagina Export.

Link to this sectionFAQ#

Link to this sectionCome addestrare un modello di stima della profondità YOLO26 su un dataset personalizzato?#

Prepara immagini RGB in coppia e file di profondità .npy, quindi crea un file YAML del dataset che punti alla tua directory images/. Il caricatore trova automaticamente i file di profondità sostituendo images con depth nel percorso e scambiando l'estensione dell'immagine con .npy.

Parti da pesi pre-addestrati e utilizza un learning rate basso con AdamW affinché il fine-tuning mantenga ciò che il modello già conosce (vedi Fine-tuning sui tuoi dati per il motivo):

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

Controlla la pagina Configurazione per ulteriori argomenti disponibili.

Link to this sectionQuali metriche riporta la stima della profondità YOLO26?#

La validazione della stima della profondità riporta il set di metriche utilizzato da Depth Anything e dai relativi lavori sulla profondità monoculare:

• delta1 / delta2 / delta3 — percentuale di pixel in cui il rapporto tra la profondità prevista e quella reale (o il suo inverso) è inferiore rispettivamente a 1,25, 1,25² e 1,25³. Più alto è, meglio è.
• abs_rel — errore relativo assoluto medio. Più basso è, meglio è.
• rmse — radice dell'errore quadratico medio in metri. Più basso è, meglio è.
• silog — errore logaritmico invariante alla scala. Più basso è, meglio è.

Ogni previsione è allineata alla mediana rispetto alla sua realtà di base per immagine, e le statistiche vengono poi raggruppate su ogni pixel valido del set di validazione (le immagini con più pixel di profondità validi pesano proporzionalmente di più). I documenti che invece mediano le metriche per immagine possono riportare valori leggermente diversi sulle stesse previsioni.

Link to this sectionQual è il formato di output della mappa di profondità?#

La mappa di profondità è archiviata come un torch.Tensor di forma (H, W) dove ogni valore è la profondità prevista in metri (usa result.depth.data.cpu().numpy() per un array NumPy float32). Accedi tramite result.depth.data dopo aver eseguito la previsione. La mappa è allineata alla risoluzione dell'immagine di input.

Link to this sectionQuali dataset sono supportati per la stima della profondità?#

Ultralytics YOLO26 fornisce configurazioni YAML del dataset integrate per diversi dataset di stima della profondità, inclusi NYU Depth V2, KITTI, Hypersim, SUN RGB-D e ARKitScenes. Vedi la Guida ai dataset di stima della profondità per l'elenco completo e i dettagli sul formato.

Link to this sectionCome posso convalidare un modello di stima della profondità YOLO26 pre-addestrato?#

Convalida un modello di profondità YOLO26 pre-addestrato fornendo il file YAML del dataset utilizzato per la valutazione:

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 sectionCome posso esportare un modello di stima della profondità YOLO26 in formato ONNX?#

Esporta un modello di profondità YOLO26 in ONNX con Python o CLI:

from ultralytics import YOLO

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

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

Per ulteriori dettagli sull'esportazione in vari formati, consulta la pagina Export.