Conjunto de datos de profundidad ARKitScenes#

ARKitScenes es un conjunto de datos RGB-D de interiores del mundo real y a gran escala, capturado con ARKit de Apple en dispositivos iPad Pro equipados con un escáner LiDAR. Es el mayor conjunto de datos RGB-D de interiores del mundo real de su tipo y proporciona escenas de interiores variadas capturadas de forma natural, con datos de referencia de profundidad precisos para la estimación monocular de profundidad.

Características principales#

• Capturado con el escáner LiDAR y la cámara RGB de ARKit de Apple en iPad Pro, genera datos de sensor reales (no sintéticos).
• Abarca escenas diversas de interior para comprender escenas interiores en 3D.
• Rango de profundidad corto, de aproximadamente 0,5–6 m (profundidad máxima mediana de unos 2,4 m), típico de las capturas en interiores con dispositivos de mano.
• Verdad de referencia de profundidad densa, derivada de LiDAR y alineada con los fotogramas RGB.
• La mayor fuente del mundo real en la mezcla de preentrenamiento de profundidad de Ultralytics.

Estructura del conjunto de datos#

El conjunto de datos de profundidad ARKitScenes se divide en dos subconjuntos:

1. Train: 676.080 imágenes con mapas de profundidad emparejados para el entrenamiento.
2. Val: 21.559 imágenes con mapas de profundidad emparejados para la validación durante el entrenamiento del modelo.

Cada muestra consta de una imagen RGB y un PNG de profundidad uint16 emparejado en milímetros (depth_scale: 1000), de acuerdo con el formato de conjunto de datos de profundidad de Ultralytics. Estas cifras corresponden al subconjunto utilizado para los modelos publicados, creado a partir de 4.347 de los 4.520 vídeos de entrenamiento y 102 de los 551 vídeos de validación; al convertir las divisiones completas se obtienen más pares.

Obtén los datos#

ARKitScenes no admite la descarga automática: Apple distribuye los datos y, para descargarlos, debes aceptar las condiciones de la licencia en el repositorio de ARKitScenes. Clona el repositorio y descarga los recursos lowres_wide (RGB) y lowres_depth del subconjunto raw, que incluye las divisiones completas de 4.520 vídeos de entrenamiento y 551 vídeos de validación. Es obligatorio indicar una lista de vídeos; si pasas el CSV de la división sin --split, se descargan ambas particiones en una sola llamada:

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

Los fotogramas se guardan en data/raw/{Training,Validation}/<video_id>/{lowres_wide,lowres_depth}/. Reserva unos 2,5 TB de espacio en disco: los flujos sin procesar se capturan a ~60 FPS y la conversión de abajo conserva uno de cada 30 fotogramas (~2 Hz).

Los fotogramas de profundidad son archivos PNG uint16 en milímetros (0 = no válido), y los nombres de archivo RGB y de profundidad son marcas de tiempo de captura que no coinciden exactamente: empareja cada fotograma RGB con el fotograma de profundidad cuya marca de tiempo sea más cercana. Conversión de referencia al formato de conjunto de datos de profundidad de 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")

Papel de YOLO26-Depth#

ARKitScenes es una fuente de entrenamiento en la mezcla de preentrenamiento de varios conjuntos de datos de Ultralytics YOLO26-Depth, que contiene aproximadamente 2,19 millones de pares de imagen y profundidad. Como es la mayor fuente real de esta mezcla, aporta abundantes datos reales de profundidad LiDAR en interiores que afianzan la precisión del modelo a corta distancia en interiores. Los modelos resultantes se evalúan con los benchmarks estándar NYU, KITTI, Make3D, ETH3D e iBims-1.

YAML del conjunto de datos#

Se utiliza un archivo YAML para definir la configuración del conjunto de datos. Contiene información sobre las rutas, las clases y otros datos relevantes del conjunto.

# 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

Uso#

Para entrenar un modelo YOLO26n-depth con el conjunto de datos ARKitScenes y un tamaño de imagen de 640, puedes usar los siguientes fragmentos de código. Consulta la página de entrenamiento del modelo para ver una lista completa de los argumentos disponibles.

from ultralytics import YOLO

# Cargar un modelo
model = YOLO("yolo26n-depth.pt")  # carga un modelo de profundidad preentrenado (recomendado para el entrenamiento)

# Entrenar el modelo
results = model.train(data="depth-arkitscenes.yaml", epochs=100, imgsz=640)

Modelos preentrenados#

La familia de modelos YOLO26 de profundidad se entrena con una amplia mezcla de preentrenamiento de profundidad de varios conjuntos de datos, de la que forma parte ARKitScenes. Estos modelos se descargan automáticamente la primera vez que se usan desde la versión de recursos v8.4.0 de Ultralytics; por ejemplo, YOLO26x-depth. Hay varios tamaños para adaptarse a distintos requisitos de precisión y recursos.

Citas y agradecimientos#

Si utilizas el conjunto de datos ARKitScenes en tus investigaciones o trabajos de desarrollo, cita el siguiente artículo:

@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}
}

Queremos agradecer a los autores la creación y el mantenimiento de este valioso recurso para la comunidad de visión artificial.

Preguntas frecuentes#