Conjunto de dados de profundidade ARKitScenes#

ARKitScenes é um conjunto de dados RGB-D de ambientes internos do mundo real, em grande escala, capturado com o ARKit da Apple em dispositivos iPad Pro equipados com um scanner LiDAR. É o maior conjunto de dados RGB-D de ambientes internos do mundo real do género, com cenas internas diversificadas capturadas em condições naturais e dados de referência de profundidade precisos para a estimativa monocular de profundidade.

Principais funcionalidades#

• Capturado com o scanner LiDAR e a câmara RGB do ARKit da Apple em iPad Pro, produzindo dados reais do sensor (não sintéticos).
• Abrange cenas interiores diversificadas para a compreensão de cenas interiores em 3D.
• Faixa de profundidade curta, de aproximadamente 0,5 a 6 m (profundidade máxima mediana em torno de 2,4 m), típica de capturas internas feitas com dispositivos portáteis.
• Ground truth de profundidade denso, derivado de LiDAR e alinhado aos quadros RGB.
• A maior fonte do mundo real no conjunto de pré-treinamento de profundidade da Ultralytics.

Estrutura do conjunto de dados#

O conjunto de dados de profundidade ARKitScenes é dividido em dois subconjuntos:

1. Treino: 676.080 imagens com mapas de profundidade correspondentes para treinamento.
2. Val: 21.559 imagens com mapas de profundidade correspondentes para validação durante o treinamento do modelo.

Cada amostra consiste em uma imagem RGB e um PNG de profundidade uint16 correspondente, em milímetros (depth_scale: 1000), seguindo o formato de conjunto de dados de profundidade da Ultralytics. Esses números correspondem ao subconjunto usado nos modelos disponibilizados, criado a partir de 4.347 dos 4.520 vídeos de treinamento e 102 dos 551 vídeos de validação; a conversão das divisões completas gera mais pares.

Obter os dados#

O ARKitScenes não oferece download automático — os dados são distribuídos pela Apple, e o download exige aceitar os termos de licença no repositório do ARKitScenes. Clone o repositório e baixe os recursos lowres_wide (RGB) e lowres_depth do subconjunto raw, que abrange todas as divisões de 4.520 vídeos de treinamento e 551 vídeos de validação. É obrigatório informar uma lista de vídeos; se você passar o CSV da divisão sem --split, as duas partições serão baixadas em uma única chamada:

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

Os quadros são salvos em data/raw/{Training,Validation}/<video_id>/{lowres_wide,lowres_depth}/. Reserve cerca de 2,5 TB de espaço em disco: os fluxos brutos são gravados a ~60 FPS, e a conversão abaixo mantém um a cada 30 quadros (~2 Hz).

Os quadros de profundidade são PNGs uint16 em milímetros (0 = inválido), e os nomes de arquivo RGB/de profundidade correspondem a registros de data e hora de captura que não coincidem exatamente — associe cada quadro RGB ao quadro de profundidade com o registro de data e hora mais próximo. Conversão de referência para o formato de conjunto de dados de profundidade da 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 no YOLO26-Depth#

O ARKitScenes é uma fonte de treinamento no conjunto de pré-treinamento multidataset YOLO26-Depth da Ultralytics, com aproximadamente 2,19 milhões de pares de imagem e profundidade. Como a maior fonte real desse conjunto, fornece uma grande quantidade de profundidade LiDAR interna real, que serve de referência para a precisão do modelo em distâncias curtas em ambientes internos. Os modelos resultantes são avaliados nos benchmarks padrão NYU, KITTI, Make3D, ETH3D e iBims-1.

YAML do conjunto de dados#

Um arquivo YAML é usado para definir a configuração do conjunto de dados. Ele contém informações sobre os caminhos, as classes e outros dados relevantes do 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 treinar um modelo YOLO26n-depth no conjunto de dados ARKitScenes com tamanho de imagem 640, você pode usar os trechos de código a seguir. Para ver a lista completa de argumentos disponíveis, consulte a página de treinamento do modelo.

from ultralytics import YOLO

# Carregar um modelo
model = YOLO("yolo26n-depth.pt")  # carrega um modelo de profundidade pré-treinado (recomendado para treinamento)

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

Modelos pré-treinados#

A família YOLO26 de modelos de profundidade é treinada com o amplo conjunto de pré-treinamento multidataset de profundidade do qual o ARKitScenes faz parte. Esses modelos são baixados automaticamente no primeiro uso, a partir da versão de recursos v8.4.0 da Ultralytics; um exemplo é o YOLO26x-depth. A família inclui vários tamanhos para atender a diferentes requisitos de precisão e recursos.

Citações e agradecimentos#

Se você usar o conjunto de dados ARKitScenes em seu trabalho de pesquisa ou desenvolvimento, cite o artigo a seguir:

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

Agradecemos aos autores por criarem e manterem este valioso recurso para a comunidade de visão computacional.

Perguntas frequentes#