Jeu de données de profondeur ARKitScenes#

ARKitScenes est un jeu de données RGB-D intérieur réel à grande échelle, capturé avec ARKit d’Apple sur des iPad Pro équipés d’un scanner LiDAR. Il s’agit du plus grand jeu de données RGB-D intérieur réel de ce type, offrant des scènes intérieures variées capturées dans des conditions naturelles et des données de vérité terrain de profondeur précises pour l’estimation monoculaire de la profondeur.

Fonctionnalités clés#

• Capturé avec le scanner LiDAR et la caméra RGB d’ARKit d’Apple sur iPad Pro, produisant des données de capteurs réelles (non synthétiques).
• Couvre diverses scènes intérieures pour la compréhension des scènes intérieures en 3D.
• Plage de profondeur courte, d’environ 0,5 à 6 m (profondeur maximale médiane d’environ 2,4 m), typique des captures en intérieur réalisées à la main.
• Vérité terrain de profondeur dense, dérivée du LiDAR et alignée sur les images RGB.
• La plus grande source réelle du mélange de préentraînement en profondeur d’Ultralytics.

Structure du jeu de données#

Le jeu de données de profondeur ARKitScenes est réparti en deux sous-ensembles :

1. Train : 676,080 images avec des cartes de profondeur associées pour l’entraînement.
2. Val : 21,559 images avec des cartes de profondeur associées pour la validation pendant l’entraînement du modèle.

Chaque échantillon comprend une image RGB et une image PNG de profondeur uint16 associée, en millimètres (depth_scale: 1000), conformément au format de jeu de données de profondeur Ultralytics. Ces nombres correspondent au sous-ensemble utilisé pour les modèles publiés, constitué de 4,347 des 4,520 vidéos d’entraînement et de 102 des 551 vidéos de validation ; la conversion des partitions complètes produit davantage de paires.

Obtenir les données#

ARKitScenes ne propose pas de téléchargement automatique : les données sont distribuées par Apple, et leur téléchargement nécessite d’accepter les conditions de licence dans le dépôt ARKitScenes. Clone le dépôt et télécharge les ressources lowres_wide (RGB) et lowres_depth du sous-ensemble raw, qui couvre l’intégralité des partitions d’entraînement (4,520 vidéos) et de validation (551 vidéos). Une liste de vidéos est obligatoire ; en transmettant le fichier CSV de partition sans --split, tu récupères les deux partitions en un seul appel :

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

Les images sont enregistrées dans data/raw/{Training,Validation}/<video_id>/{lowres_wide,lowres_depth}/. Prévois environ 2,5 To d’espace disque : les flux bruts tournent à ~60 FPS, et la conversion ci-dessous conserve une image sur 30 (~2 Hz).

Les images de profondeur sont des fichiers PNG uint16 en millimètres (0 = invalide), et les noms de fichiers RGB/profondeur correspondent à des horodatages de capture qui ne coïncident pas exactement — associe chaque image RGB à l’image de profondeur dont l’horodatage est le plus proche. Conversion de référence vers le format de jeu de données de profondeur 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")

Rôle dans YOLO26-Depth#

ARKitScenes est une source d’entraînement du mélange de préentraînement multi-jeux de données Ultralytics YOLO26-Depth, qui contient environ 2.19M paires image-profondeur. En tant que plus grande source réelle de ce mélange, il fournit une abondance de profondeurs LiDAR réelles en intérieur, qui ancrent la précision du modèle à courte portée en intérieur. Les modèles obtenus sont évalués sur les benchmarks standard NYU, KITTI, Make3D, ETH3D et iBims-1.

Fichier YAML du jeu de données#

Un fichier YAML sert à définir la configuration du jeu de données. Il contient des informations sur les chemins d’accès, les classes et d’autres éléments pertinents du jeu de données.

# 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

Utilisation#

Pour entraîner un modèle YOLO26n-depth sur le jeu de données ARKitScenes avec une taille d’image de 640, utilise les extraits de code suivants. Pour consulter la liste complète des arguments disponibles, reporte-toi à la page Entraînement du modèle.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n-depth.pt")  # charger un modèle de profondeur préentraîné (recommandé pour l’entraînement)

# Entraîner le modèle
results = model.train(data="depth-arkitscenes.yaml", epochs=100, imgsz=640)

Modèles préentraînés#

La famille de modèles de profondeur YOLO26 est entraînée sur le vaste mélange de préentraînement en profondeur multi-jeux de données auquel ARKitScenes appartient. Ces modèles se téléchargent automatiquement lors de leur première utilisation depuis la publication des ressources v8.4.0 d’Ultralytics, par exemple YOLO26x-depth, et proposent plusieurs tailles adaptées à différents besoins en matière de précision et de ressources.

Citations et remerciements#

Si tu utilises le jeu de données ARKitScenes dans tes travaux de recherche ou de développement, cite l’article suivant :

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

Nous tenons à remercier les auteurs d’avoir créé et maintenu cette précieuse ressource pour la communauté de la vision par ordinateur.

FAQ#