Dataset di profondità ARKitScenes#

ARKitScenes è un dataset RGB-D di ambienti interni reali su larga scala, acquisito con ARKit di Apple su dispositivi iPad Pro dotati di scanner LiDAR. È il più grande dataset RGB-D di ambienti interni reali del suo genere e offre scene interne varie acquisite in condizioni naturali, con ground truth della profondità accurata per la stima monoculare della profondità.

Funzionalità principali#

• Acquisito con lo scanner LiDAR e la fotocamera RGB di ARKit di Apple su iPad Pro, genera dati reali dei sensori (non sintetici).
• Copre scene interne diverse per la comprensione delle scene interne 3D.
• Intervallo di profondità ridotto, circa 0,5–6 m (profondità massima mediana intorno a 2,4 m), tipico delle acquisizioni indoor portatili.
• Ground truth di profondità densa derivata da LiDAR, allineata ai frame RGB.
• La singola fonte reale più ampia nel mix di pretraining per la profondità di Ultralytics.

Struttura del dataset#

Il dataset di profondità ARKitScenes è suddiviso in due sottoinsiemi:

1. Train: 676.080 immagini con mappe di profondità abbinate per l'addestramento.
2. Val: 21.559 immagini con mappe di profondità abbinate per la validazione durante l'addestramento del modello.

Ogni campione consiste in un'immagine RGB e una PNG di profondità uint16 abbinata, in millimetri (depth_scale: 1000), secondo il formato dei dataset di profondità Ultralytics. Questi conteggi corrispondono al sottoinsieme usato per i modelli rilasciati, ricavato da 4.347 dei 4.520 video Training e 102 dei 551 video Validation; convertendo le suddivisioni complete si ottengono più coppie.

Recuperare i dati#

ARKitScenes non dispone di download automatico: i dati sono distribuiti da Apple e per scaricarli è necessario accettare i termini di licenza nel repository ARKitScenes. Clona il repository e scarica gli asset lowres_wide (RGB) e lowres_depth del sottoinsieme raw, che copre tutte le suddivisioni Training da 4.520 video e Validation da 551 video. È obbligatorio specificare un elenco di video; passando il CSV della suddivisione senza --split si recuperano entrambi i gruppi con una sola chiamata:

git clone https://github.com/apple/ARKitScenes && cd ARKitScenes
python3 download_data.py raw --video_id_csv raw/raw_train_val_splits.csv \
  --raw_dataset_assets lowres_wide lowres_depth --download_dir ./data

I frame vengono salvati in data/raw/{Training,Validation}/<video_id>/{lowres_wide,lowres_depth}/. Prevedi circa 2,5 TB di spazio su disco: i flussi originali arrivano a ~60 FPS e la conversione qui sotto conserva un frame ogni 30 (~2 Hz).

I frame di profondità sono PNG uint16 in millimetri (0 = non valido) e i nomi dei file RGB e di profondità corrispondono ai timestamp di acquisizione, che non coincidono esattamente: abbina ogni frame RGB al frame di profondità con il timestamp più vicino. Conversione di riferimento al formato dei dataset di profondità Ultralytics:

import shutil
from bisect import bisect_left
from pathlib import Path

src, dst = Path("data/raw"), Path("datasets/depth-arkitscenes")
for split, out in (("Training", "train"), ("Validation", "val")):
    (dst / f"images/{out}").mkdir(parents=True, exist_ok=True)
    (dst / f"depth/{out}").mkdir(parents=True, exist_ok=True)
    for video in sorted((src / split).iterdir()):
        depths = sorted((video / "lowres_depth").glob("*.png"), key=lambda p: float(p.stem.split("_")[-1]))
        if not depths:
            continue
        times = [float(p.stem.split("_")[-1]) for p in depths]
        rgbs = sorted((video / "lowres_wide").glob("*.png"), key=lambda p: float(p.stem.split("_")[-1]))
        for rgb in rgbs[30::30]:  # every 30th frame of the ~60 FPS capture (~2 Hz)
            t = float(rgb.stem.split("_")[-1])
            i = min(bisect_left(times, t), len(times) - 1)
            if i and t - times[i - 1] < times[i] - t:
                i -= 1  # nearest-timestamp depth frame
            name = f"{out}_{video.name}_{depths[i].stem}"
            shutil.copy2(rgb, dst / f"images/{out}/{name}.png")
            shutil.copy2(depths[i], dst / f"depth/{out}/{name}.png")

Ruolo in YOLO26-Depth#

ARKitScenes è una fonte di addestramento nel mix di pretraining multi-dataset di Ultralytics YOLO26-Depth, composto da circa 2,19 milioni di coppie immagine–profondità. Essendo la singola fonte reale più ampia del mix, fornisce un'abbondanza di profondità LiDAR indoor reali che costituisce un punto di riferimento per l'accuratezza del modello a corto raggio in ambienti interni. I modelli risultanti vengono valutati sui benchmark standard NYU, KITTI, Make3D, ETH3D e iBims-1.

YAML del dataset#

Per definire la configurazione del dataset si usa un file YAML. Contiene informazioni sui percorsi del dataset, sulle classi e su altri dettagli pertinenti.

# Ultralytics 🚀 AGPL-3.0 License - https://ultralytics.com/license

# ARKitScenes dataset for monocular depth estimation — real indoor RGB-D from Apple ARKit (iPad Pro LiDAR), depth ~0.5-6 m
# Documentation: https://docs.ultralytics.com/datasets/depth/arkitscenes
# Example usage: yolo depth train data=depth-arkitscenes.yaml model=yolo26n-depth.pt
# No autodownload — obtain the source data (see docs) and arrange it as below.
# parent
# ├── ultralytics
# └── datasets
#     └── depth-arkitscenes
#         ├── images/{train,val}  # RGB images
#         └── depth/{train,val}   # paired 16-bit *.png depth maps (images/ -> depth/)

path: depth-arkitscenes # dataset root dir (relative to Ultralytics settings 'datasets_dir')
train: images/train # train images (relative to 'path') 676080 images
val: images/val # val images (relative to 'path') 21559 images

nc: 1
names:
  0: depth

channels: 3

Utilizzo#

Per addestrare un modello YOLO26n-depth sul dataset ARKitScenes con una dimensione dell'immagine di 640, puoi usare i seguenti frammenti di codice. Per un elenco completo degli argomenti disponibili, consulta la pagina Addestramento del modello.

from ultralytics import YOLO

# Carica un modello
model = YOLO("yolo26n-depth.pt")  # carica un modello di profondità preaddestrato (consigliato per l'addestramento)

# Addestra il modello
results = model.train(data="depth-arkitscenes.yaml", epochs=100, imgsz=640)

Modelli preaddestrati#

La famiglia YOLO26 depth viene addestrata sul vasto mix di pretraining multi-dataset per la profondità, di cui fa parte ARKitScenes. Al primo utilizzo, questi modelli vengono scaricati automaticamente dalla versione degli asset v8.4.0 di Ultralytics, ad esempio YOLO26x-depth, e sono disponibili in diverse dimensioni per soddisfare requisiti differenti di accuratezza e risorse.

Citazioni e ringraziamenti#

Se usi il dataset ARKitScenes nel tuo lavoro di ricerca o sviluppo, cita il seguente articolo:

@inproceedings{baruch2021arkitscenes,
      title={ARKitScenes: A Diverse Real-World Dataset for 3D Indoor Scene Understanding Using Mobile RGB-D Data},
      author={Baruch, Gilad and Chen, Zhuoyuan and Dehghan, Afshin and Dimry, Tal and Feigin, Yuri and Fu, Peter and Gebauer, Thomas and Joffe, Brandon and Kurz, Daniel and Schwartz, Arik and Shulman, Elad},
      booktitle={Thirty-fifth Conference on Neural Information Processing Systems Datasets and Benchmarks Track},
      year={2021}
}

Desideriamo ringraziare gli autori per aver creato e mantenuto questa preziosa risorsa per la comunità della computer vision.

Domande frequenti#