Jeu de données de profondeur Hypersim#

Hypersim est un jeu de données synthétique photoréaliste de scènes d’intérieur, conçu pour une compréhension globale des scènes intérieures. Ses images sont calculées par lancer de rayons à partir d’intérieurs 3D Evermotion créés par des professionnels, ce qui produit des rendus très réalistes associés à des vérités terrain de profondeur denses et exactes pour chaque pixel.

Hypersim étant entièrement synthétique, chaque pixel possède une valeur de profondeur exacte, sans bruit de capteur, retour manquant ni artefact de mesure. C’est donc une excellente source de géométrie intérieure propre et dense pour entraîner des modèles d’estimation de profondeur monoculaire.

Fonctionnalités clés#

• Scènes d’intérieur synthétiques photoréalistes, calculées par lancer de rayons à partir d’intérieurs 3D Evermotion professionnels.
• Environnements intérieurs uniquement.
• Vérité terrain de profondeur dense et exacte pour chaque pixel, sans bruit de capteur ni valeur manquante.
• Plage de profondeur généralement ≤10 m (avec quelques distances supérieures).
• Contribue à hauteur de 74,619 images (68,242 pour l’entraînement / 6,377 pour la validation) au mélange de données d’entraînement en profondeur d’Ultralytics.

Structure du jeu de données#

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

1. Entraînement : 68,242 images avec des cartes de profondeur denses associées pour l’entraînement.
2. Validation : 6,377 images avec des cartes de profondeur denses associées pour la validation pendant l’entraînement.

Chaque image RGB est associée à un PNG de profondeur uint16 mis à l’échelle, conformément au format de jeu de données de profondeur Ultralytics.

Obtenir les données#

Hypersim ne propose pas de téléchargement automatique : Apple distribue le jeu de données (~1.9 TB d’archives ZIP par scène) sous la licence CC BY-SA 3.0. Télécharge-le avec le script officiel du dépôt ml-hypersim (un outil de téléchargement sélectif est disponible dans contrib/99991) :

git clone https://github.com/apple/ml-hypersim && cd ml-hypersim
python code/python/tools/dataset_download_images.py --downloads_dir ./downloads --decompress_dir ./scenes

Les images RGB sont les aperçus frame.*.tonemap.jpg et la profondeur se trouve dans frame.*.depth_meters.hdf5. Les valeurs stockées sont des distances le long des rayons jusqu’au centre de la caméra, et non une profondeur planaire — convertis-les avant de les enregistrer et associe les pixels NaN (fenêtres, ciel) à 0 (valeur invalide). Utilise la répartition officielle des scènes metadata_images_split_scene_v1.csv pour attribuer les données aux ensembles d’entraînement et de validation. Référence pour la conversion au format de jeu de données de profondeur Ultralytics :

import shutil
from pathlib import Path

import h5py
import numpy as np

from ultralytics.data.utils import save_depth_png

W, H, FOCAL = 1024, 768, 886.81  # Hypersim camera intrinsics
x, y = np.meshgrid(np.linspace(-W / 2, W / 2, W), np.linspace(-H / 2, H / 2, H))
ray2plane = (FOCAL / np.sqrt(x**2 + y**2 + FOCAL**2)).astype(np.float32)  # distance → planar depth

src, dst = Path("scenes"), Path("datasets/depth-hypersim")
out = "train"  # assign per scene from metadata_images_split_scene_v1.csv
(dst / f"images/{out}").mkdir(parents=True, exist_ok=True)
(dst / f"depth/{out}").mkdir(parents=True, exist_ok=True)
for h5 in sorted(src.rglob("*.depth_meters.hdf5")):
    scene, cam, frame = h5.parts[-4], h5.parent.name.split("_geometry")[0], h5.name.split(".")[1]
    rgb = h5.parents[1] / f"{cam}_final_preview" / f"frame.{frame}.tonemap.jpg"
    dist = np.asarray(h5py.File(h5)["dataset"], np.float32)
    depth = np.nan_to_num(dist * ray2plane, nan=0.0)  # NaN (sky, glass) → 0 = invalid
    name = f"{scene}_{cam}_{frame}"
    save_depth_png(dst / f"depth/{out}/{name}.png", depth)
    shutil.copy(rgb, dst / f"images/{out}/{name}.jpg")

Rôle dans YOLO26-Depth#

Hypersim est l’une des sources d’entraînement du vaste mélange de plusieurs jeux de données (~2.19M images) utilisé pour préentraîner les modèles YOLO26-Depth d’Ultralytics. Dans ce mélange, Hypersim apporte une géométrie intérieure propre et dense qui complète les données plus bruitées des capteurs du monde réel.

Cette configuration ne comprend aucun benchmark Hypersim distinct avec des données mises à l’écart pour l’évaluation. Les modèles obtenus sont plutôt évalués sur les benchmarks standard de profondeur monoculaire : NYU Depth V2, 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, les classes et d’autres éléments pertinents. Pour Hypersim, le fichier depth-hypersim.yaml définit les chemins et l’unique classe depth.

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

# Hypersim dataset for monocular depth estimation — photorealistic synthetic indoor (ray-traced), dense depth up to ~10 m
# Documentation: https://docs.ultralytics.com/datasets/depth/hypersim
# Example usage: yolo depth train data=depth-hypersim.yaml model=yolo26n-depth.pt
# No autodownload — obtain the source data (see docs) and arrange it as below.
# parent
# ├── ultralytics
# └── datasets
#     └── depth-hypersim
#         ├── images/{train,val}  # RGB images
#         └── depth/{train,val}   # paired 16-bit *.png depth maps (images/ -> depth/)

path: depth-hypersim # dataset root dir (relative to Ultralytics settings 'datasets_dir')
train: images/train # train images (relative to 'path') 68242 images
val: images/val # val images (relative to 'path') 6377 images

nc: 1
names:
  0: depth

channels: 3

Utilisation#

Pour entraîner un modèle YOLO26n-Depth sur le jeu de données Hypersim avec une taille d’image de 640, tu peux utiliser 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 préentraîné (recommandé pour l’entraînement)

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

Modèles préentraînés#

La famille de modèles de profondeur YOLO26 (yolo26n-depth.pt, yolo26s-depth.pt, yolo26m-depth.pt, yolo26l-depth.pt, yolo26x-depth.pt) se télécharge automatiquement depuis les publications d’Ultralytics et est entraînée sur le vaste mélange de plusieurs jeux de données auquel Hypersim contribue. Découvre YOLO26x-depth sur Ultralytics Platform.

Citations et remerciements#

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

@inproceedings{roberts2021hypersim,
      title={Hypersim: A Photorealistic Synthetic Dataset for Holistic Indoor Scene Understanding},
      author={Mike Roberts and Jason Ramapuram and Anurag Ranjan and Atulit Kumar and Miguel Angel Bautista and Nathan Paczan and Russ Webb and Joshua M. Susskind},
      booktitle={Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV)},
      year={2021}
}

Nous remercions les créateurs d’Hypersim d’avoir mis ce jeu de données synthétique photoréaliste d’intérieur à la disposition de la communauté de la vision par ordinateur.

FAQ#