Link to this sectionJeu 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 espaces intérieurs. Ses images sont générées par lancer de rayons à partir d'intérieurs 3D Evermotion créés par des professionnels, produisant des rendus hautement réalistes associés à une vérité terrain de profondeur dense et parfaite par pixel.

Comme Hypersim est entièrement synthétique, chaque pixel possède une valeur de profondeur exacte sans bruit de capteur, sans données manquantes ni artefacts de mesure. Cela en fait une excellente source de géométrie intérieure propre et dense pour l'entraînement de modèles d'estimation de profondeur monoculaire.

Link to this sectionFonctionnalités clés#

• Scènes d'intérieur synthétiques photoréalistes, générées par lancer de rayons à partir d'intérieurs 3D professionnels Evermotion.
• Environnements intérieurs uniquement.
• Vérité terrain de profondeur par pixel dense et parfaite, sans bruit de capteur ni valeurs manquantes.
• Plage de profondeur majoritairement ≤10 m (avec quelques distances plus grandes).
• Contribue à hauteur de 74 619 images (68 242 pour l'entraînement / 6 377 pour la validation) au mélange d'entraînement de profondeur Ultralytics.

Link to this sectionStructure du jeu de données#

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

1. Train : 68 242 images avec cartes de profondeur denses associées pour l'entraînement.
2. Val : 6 377 images avec cartes de profondeur denses associées pour la validation pendant l'entraînement.

Chaque image RVB est associée à une carte de profondeur .npy en float32 stockant les distances par pixel en mètres, conformément au format de jeu de données de profondeur Ultralytics.

Link to this sectionObtenir les données#

Hypersim ne dispose pas de téléchargement automatique — le jeu de données (~1,9 To de fichiers ZIP par scène) est distribué par Apple sous la licence CC BY-SA 3.0 et téléchargé via le script officiel du dépôt ml-hypersim (un téléchargeur 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 RVB sont les aperçus frame.*.tonemap.jpg et la profondeur réside dans frame.*.depth_meters.hdf5. Les valeurs stockées sont des distances de rayon par rapport au centre de la caméra, pas de la profondeur planaire — convertis-les avant de les enregistrer, et mappe les pixels NaN (fenêtres, ciel) à 0 (invalide). Utilise la séparation de scènes officielle metadata_images_split_scene_v1.csv pour l'assignation train/val. Référence pour la conversion vers le format de jeu de données de profondeur Ultralytics :

import shutil
from pathlib import Path

import h5py
import numpy as np

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}"
    np.save(dst / f"depth/{out}/{name}.npy", depth)
    shutil.copy(rgb, dst / f"images/{out}/{name}.jpg")

Link to this sectionRôle dans YOLO26-Depth#

Hypersim est l'une des sources d'entraînement dans le vaste mélange multi-jeux de données (~2,19M d'images) utilisé pour pré-entraîner les modèles Ultralytics YOLO26-Depth. Au sein de ce mélange, Hypersim apporte une géométrie intérieure propre et dense qui complète les données de capteurs réelles plus bruitées.

Il n'existe pas de benchmark Hypersim isolé et distinct dans cette configuration. Au lieu de cela, les modèles résultants sont évalués sur les benchmarks standard de profondeur monoculaire : NYU Depth V2, KITTI, Make3D, ETH3D et iBims-1.

Link to this sectionYAML du jeu de données#

Un fichier YAML (Yet Another Markup Language) est utilisé pour définir la configuration du jeu de données. Il contient des informations sur les chemins du jeu de données, les classes et d'autres informations pertinentes. 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 *.npy, float32 meters (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

Link to this sectionUtilisation#

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 une liste complète des arguments disponibles, consulte la page Entraînement du modèle.

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n-depth.pt")  # load a pretrained model (recommended for training)

# Train the model
results = model.train(data="depth-hypersim.yaml", epochs=100, imgsz=640)

Link to this sectionModèles pré-entraînés#

La famille de profondeur YOLO26 (yolo26n-depth.pt, yolo26s-depth.pt, yolo26m-depth.pt, yolo26l-depth.pt, yolo26x-depth.pt) se télécharge automatiquement depuis la version v8.4.0 et est entraînée sur le vaste mélange multi-jeux de données dont Hypersim fait partie.

Link to this sectionCitations et remerciements#

Si tu utilises le jeu de données Hypersim dans tes travaux de recherche ou de développement, merci de citer 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 tenons à remercier les créateurs d'Hypersim pour avoir rendu ce jeu de données d'intérieur synthétique photoréaliste disponible pour la communauté de vision par ordinateur.