ARKitScenes-Tiefendatensatz#

ARKitScenes ist ein groß angelegter RGB-D-Datensatz aus realen Innenräumen. Er wurde mit Apples ARKit auf iPad-Pro-Geräten mit LiDAR-Scanner aufgenommen. Es ist der größte RGB-D-Datensatz seiner Art aus realen Innenräumen. Er enthält vielfältige, natürlich aufgenommene Innenraumszenen mit präzisen Tiefenreferenzdaten für die monokulare Tiefenschätzung.

Wichtige Funktionen#

• Mit dem LiDAR-Scanner und der RGB-Kamera von Apples ARKit auf einem iPad Pro aufgenommen; die Daten stammen von realen (nicht synthetischen) Sensoren.
• Umfasst vielfältige Innenraumszenen für das Verständnis von 3D-Innenraumszenen.
• Kurzer Tiefenbereich von etwa 0,5–6 m (mediane maximale Tiefe etwa 2,4 m), typisch für handgeführte Aufnahmen in Innenräumen.
• Dichte, aus LiDAR abgeleitete Tiefenreferenzdaten, die auf die RGB-Bilder abgestimmt sind.
• Die mit Abstand größte reale Datenquelle im Tiefen-Vortrainingsmix von Ultralytics.

Datensatzstruktur#

Der Tiefendatensatz ARKitScenes ist in zwei Teilmengen aufgeteilt:

1. Train: 676.080 Bilder mit zugehörigen Tiefenkarten für das Training.
2. Val: 21.559 Bilder mit zugehörigen Tiefenkarten für die Validierung während des Modelltrainings.

Jedes Sample besteht aus einem RGB-Bild und einer zugehörigen uint16-Tiefen-PNG-Datei in Millimetern (depth_scale: 1000) gemäß dem Tiefendatensatzformat von Ultralytics. Diese Zahlen beziehen sich auf die für die veröffentlichten Modelle verwendete Teilmenge, die aus 4.347 der 4.520 Trainingsvideos und 102 der 551 Validierungsvideos erstellt wurde; die Konvertierung der vollständigen Teilmengen ergibt mehr Paare.

Daten beschaffen#

ARKitScenes lässt sich nicht automatisch herunterladen – Apple verteilt die Daten, und für den Download musst du die Lizenzbedingungen im ARKitScenes-Repository akzeptieren. Klone das Repository und lade die Ressourcen lowres_wide (RGB) und lowres_depth der raw-Teilmenge herunter, die die vollständigen Aufteilungen mit 4.520 Trainingsvideos und 551 Validierungsvideos umfasst. Eine Videoliste ist erforderlich. Wenn du die CSV-Datei der Aufteilung ohne --split übergibst, werden beide Teilmengen mit einem Aufruf abgerufen:

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

Die Bilder werden in data/raw/{Training,Validation}/<video_id>/{lowres_wide,lowres_depth}/ abgelegt. Plane etwa 2,5 TB Speicherplatz ein: Die Rohdatenströme laufen mit ~60 FPS, und bei der folgenden Konvertierung bleibt jedes 30. Bild erhalten (~2 Hz).

Tiefenbilder sind uint16-PNG-Dateien in Millimetern (0 = ungültig). Da RGB- und Tiefendateinamen Zeitstempel der Aufnahmen enthalten, die nicht genau übereinstimmen, ordne jedes RGB-Bild dem Tiefenbild mit dem nächstliegenden Zeitstempel zu. Beispielkonvertierung in das Tiefendatensatzformat von 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")

Rolle in YOLO26-Depth#

ARKitScenes ist eine Trainingsquelle im Multi-Datensatz-Vortrainingsmix für Ultralytics YOLO26-Depth, der etwa 2,19 Mio. Bild-Tiefen-Paare umfasst. Als größte reale Datenquelle in diesem Mix liefert ARKitScenes eine Fülle echter LiDAR-Tiefendaten aus Innenräumen, die die Genauigkeit des Modells im Nahbereich in Innenräumen verankern. Die resultierenden Modelle werden anhand der Standard-Benchmarks NYU, KITTI, Make3D, ETH3D und iBims-1 bewertet.

YAML-Datei des Datensatzes#

Eine YAML-Datei legt die Dataset-Konfiguration fest. Sie enthält Angaben zu den Pfaden, Klassen und weiteren relevanten Informationen des Datensatzes.

# 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

Verwendung#

Um ein YOLO26n-depth-Modell mit einer Bildgröße von 640 auf dem Datensatz ARKitScenes zu trainieren, kannst du die folgenden Codebeispiele verwenden. Eine vollständige Liste der verfügbaren Argumente findest du auf der Seite zum Training des Modells.

from ultralytics import YOLO

# Ein Modell laden
model = YOLO("yolo26n-depth.pt")  # Ein vortrainiertes Tiefenmodell laden (für das Training empfohlen)

# Das Modell trainieren
results = model.train(data="depth-arkitscenes.yaml", epochs=100, imgsz=640)

Vortrainierte Modelle#

Die YOLO26-Tiefenmodellfamilie wird mit dem umfangreichen Multi-Datensatz-Tiefen-Vortrainingsmix trainiert, zu dem auch ARKitScenes gehört. Diese Modelle werden bei der ersten Verwendung automatisch aus der Ultralytics-Version v8.4.0 assets release heruntergeladen, zum Beispiel YOLO26x-depth. Es gibt sie in verschiedenen Größen für unterschiedliche Genauigkeits- und Ressourcenanforderungen.

Zitate und Danksagungen#

Wenn du den Datensatz ARKitScenes für deine Forschungs- oder Entwicklungsarbeit verwendest, zitiere bitte die folgende Arbeit:

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

Wir möchten den Autorinnen und Autoren dafür danken, dass sie diese wertvolle Ressource für die Bildverarbeitungsgemeinschaft erstellt haben und pflegen.

Häufig gestellte Fragen#