Upload README.md with huggingface_hub

README.md

@@ -28,20 +28,51 @@ tags:
 
 ![Hero — four warehouse-safety scenarios in synchronized multi-view simulation.](./assets/hero_2x2.webp)
 
-PhysicalAI SDG-Warehouse is a synthetic, fully-annotated video dataset of staged industrial-safety events captured in a simulated warehouse environment. It contains approximately 123 thousand video clips, totaling roughly 412 hours of footage at 1920 by 1080 resolution and 30 frames per second, organized across four scenarios: a forklift near-miss with a human worker, a warehouse fire with worker evacuation, a forklift collision with a populated storage shelf, and a routine box-pickup action. Every multi-camera simulation run is filmed from five to ten synchronized viewpoints, and the entire pipeline is reproducible end-to-end from a single random seed.
+PhysicalAI SDG-Warehouse is a synthetic, fully-annotated video dataset of staged industrial-safety events captured in a simulated warehouse environment. It contains approximately 123k video clips, totaling roughly 412 hours of footage at 1920x1080 resolution and 30 frames per second, organized across four scenarios: a forklift near-miss with a human worker, a warehouse fire with worker evacuation, a forklift collision with a storage shelf, and a routine box-pickup action. Every multi-camera simulation run is filmed from 5 to 10 synchronized viewpoints, and the entire pipeline is reproducible end-to-end from a single random seed.
 
 This dataset is described in Appendix A.1.5 of the Cosmos3 technical report (citation [below](#citation)). This dataset is for research and development only.
 
 ## Overview
 
-The release is packaged as standard [WebDataset](https://github.com/webdataset/webdataset) tar shards, with one sample per simulation run. Inside each shard, all of a run's synchronized camera views share the same sample key, so a single iteration of the dataset yields a complete multi-view group together with its run-level metadata. The shards are sized at approximately five gigabytes each, which is optimized for streaming directly into a training loop without first materializing the full dataset on disk.
+The release is packaged as standard [WebDataset](https://github.com/webdataset/webdataset) tar shards, with one sample per simulation run. Inside each shard, all of a run's synchronized camera views share the same sample key, so a single iteration of the dataset yields a complete multi-view group together with its run-level metadata. The shards are sized at approximately 5GBs each, which is optimized for streaming directly into a training loop without first materializing the full dataset on disk.
 
 The dataset is published in two complementary tiers under the same repository, joinable per-sample on `run_id`:
 
-- The **RGB tier** (`rgb/`) contains the photoreal RGB video for every camera in every run, plus the run-level metadata. It is 459 shards totaling approximately 2.24 tebibytes, and is the right entry point for video generation, video understanding, and any workflow that does not need pixel-level supervision.
-- The **artifacts tier** (`artifacts/`) contains the full annotation stack for the same runs: metric depth, colorized instance segmentation, shaded segmentation, and Canny edges as MP4 videos; the raw per-frame integer-id instance-segmentation arrays consolidated to a single compressed NPZ per camera; the per-camera consolidated `camera_params.jsonl` and `object_detection.jsonl` files with two- and three-dimensional bounding boxes and per-frame intrinsics and extrinsics; and the source RGB MP4s repeated in the same shard so that the artifacts tier is self-contained. The artifacts tier totals approximately 13 tebibytes across all four scenarios.
+- The **RGB tier** (`rgb/`) contains the photoreal RGB video for every camera in every run, plus per-run metadata files (`meta.json` and `metadata.txt`) embedded inside each shard. It is 459 shards totaling approximately 2.24 TiB, and is the right entry point for video generation, video understanding, and any workflow that does not need pixel-level supervision.
+- The **artifacts tier** (`artifacts/`) contains the full annotation stack for the same runs: metric depth, colorized instance segmentation, shaded segmentation, and canny edges as MP4 videos; the raw per-frame integer-id instance-segmentation arrays consolidated to a single compressed NPZ per camera; the per-camera consolidated `camera_params.jsonl` and `object_detection.jsonl` files with two- and three-dimensional bounding boxes and per-frame intrinsics and extrinsics; and the source RGB MP4s repeated in the same shard so that the artifacts tier is self-contained. The artifacts tier totals approximately 13 TiB across all four scenarios.
 
-Two small Parquet indexes (one row per run and one row per camera-clip) sit at the top of the repository and enable filtering by scenario, seed, camera, or source kind without opening a single shard.
+Two small Parquet indexes — `metadata/runs.parquet` (one row per run) and `metadata/clips.parquet` (one row per camera-clip) — enable filtering by scenario, seed, camera, or source kind without opening a single shard.
+
+## Dataset at a glance
+
+**Dataset owner(s).** NVIDIA Corporation.
+
+**Dataset creation date.** 2026-05.
+
+**License / terms of use.** Released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license.
+
+**Intended usage.** SDG-Warehouse is intended for research and development of physical-AI models — including but not limited to video understanding (action recognition, anomaly and incident detection, multi-camera person re-identification, worker activity recognition), pixel-level perception (monocular depth estimation, instance segmentation, edge prediction, 2D and 3D object detection and tracking), video generation and world modeling (text-to-video, conditional video generation, long-horizon prediction), and policy or planning research that benefits from controllable, reproducible safety-event footage. It is also a useful resource for studying sim-to-real transfer in warehouse and industrial settings, and as a controlled benchmark for evaluating model robustness across viewpoints, lighting, and agent appearance.
+
+**Dataset characterization.**
+
+- *Data collection method.* Synthetic. All footage was rendered in NVIDIA Isaac Sim using the Isaac Replicator Object and Isaac Replicator Agent components; no real-world footage was captured or used.
+- *Labeling method.* Synthetic / Automated. All ground-truth annotations (depth, segmentation, edges, bounding boxes, camera parameters) are generated by the Isaac Sim Replicator pipeline as a deterministic byproduct of rendering. No human labeling was used.
+
+**Dataset format.**
+
+- *Modalities.* Video (photoreal RGB and 4 rendered annotation modalities — colorized metric depth, colorized instance segmentation, shaded segmentation, canny edges), per-frame integer-id instance-segmentation arrays, per-frame structured annotations (2D and 3D bounding boxes, camera intrinsics and extrinsics).
+- *Container and codec.* MP4 (H.264) at 1920 × 1080, 30 fps, for both RGB and annotation videos.
+- *Structured annotations.* JSON Lines (one JSON object per frame), consolidated per camera per run into `camera_params.jsonl` and `object_detection.jsonl`.
+- *Raw instance ids.* NumPy compressed archive (`.npz`), one per camera per run, containing `frames` (`uint8[T, H, W, 4]`, the 4 channels encoding the integer id) and `frame_indices` (`int32[T]`).
+- *Run-level metadata.* JSON (`meta.json`) and plain text (`metadata.txt`), embedded inside each WebDataset shard.
+- *Packaging.* [WebDataset](https://github.com/webdataset/webdataset) tar shards, approximately 5GBs each, with one WebDataset sample per simulation run.
+- *Indexes.* Apache Parquet — `metadata/runs.parquet` (one row per run) and `metadata/clips.parquet` (one row per camera-clip).
+
+**Dataset quantification.**
+
+- *Record count.* 122,967 camera-clips drawn from 29,195 multi-camera simulation runs (WebDataset samples). Aggregate footage is approximately 412 hours.
+- *Feature count.* Per camera-clip, the dataset provides 5 video modalities (RGB, depth, instance segmentation, shaded segmentation, canny edges), 1 raw integer-id NPZ, and 2 structured-annotation JSONL files; per frame, the structured annotations contain 2D bounding boxes (both tight and loose axis-aligned), 3D oriented bounding boxes, and full camera intrinsics and extrinsics.
+- *Total data storage.* Approximately 15.2 TiB: the RGB tier is approximately 2.24 TiB (459 shards) and the artifacts tier is approximately 13 TiB (~3,130 shards).
 
 ## Why this dataset
 
@@ -51,7 +82,7 @@ We therefore generate the dataset in simulation. In a simulator, the event is gu
 
 ## Quickstart
 
-Pulling a single scenario (RGB only) is the recommended starting point for most users, since each scenario's RGB tier is a few hundred gigabytes:
+Pulling a single scenario (RGB only) is the recommended starting point for most users, since each scenario's RGB tier is a few hundred GBs:
 
 ```bash
 pip install -U "huggingface_hub[hf_xet]"
@@ -71,7 +102,7 @@ The RGB and artifact tiers per scenario are summarized below.
 | Forklift–shelf collision | `rgb/forklift_shelf_collision/` | 114 | 559 GiB | `artifacts/forklift_shelf_collision/` | ~820 | ~3.4 TiB |
 | Warehouse box pickup | `rgb/warehouse_box_pickup/` | 107 | 520 GiB | `artifacts/warehouse_box_pickup/` | 1293 | 5.14 TiB |
 
-The RGB tier totals approximately 2.24 tebibytes; the artifacts tier totals approximately 13 tebibytes. To pull a scenario together with its annotations, include both `rgb/<scenario>/**` and `artifacts/<scenario>/**`. For streaming pipelines that never materialize the data on disk, see [Loading examples](#loading-examples).
+The RGB tier totals approximately 2.24 TiB; the artifacts tier totals approximately 13 TiB. To pull a scenario together with its annotations, include both `rgb/<scenario>/**` and `artifacts/<scenario>/**`. For streaming pipelines that never materialize the data on disk, see [Loading examples](#loading-examples).
 
 ## Scenarios
 
@@ -79,43 +110,54 @@ Each scenario stages a different self-contained event inside a shared warehouse
 
 ### Forklift–human near-miss
 
-A worker stands at a fixed location while a forklift navigates along a planned path toward the same location. A configurable last-moment dodge distance distinguishes a near-miss from a direct-contact event, so the same scene composition can produce both event classes by varying a single parameter. Each multi-camera run is captured by a mixture of ceiling-mounted CCTV-style cameras (camera aliases `ceiling_00` through `ceiling_04`) and worker-height eye-level cameras (`eye_00` through `eye_04`).
+A worker stands at a fixed location while a forklift navigates along a planned path toward the same location. A configurable last-moment dodge distance distinguishes a near-miss from a direct-contact event, so the same scene composition can produce both event classes by varying a single parameter.
 
-![Forklift–human near-miss — full 10-second run shown across all five modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, Canny edges).](./assets/clip_nearmiss.webp)
+![Forklift–human near-miss — full 10-second run shown across all 5 modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, canny edges).](./assets/clip_nearmiss.webp)
 
 ### Warehouse fire
 
-A localized volumetric fire ignites at a randomized position and time while a small crew of workers performs random walks. On ignition, each worker reacts: it orients toward the flame and then runs toward a designated exit waypoint along a navigation-mesh path. The result is rare emergency-response footage that combines dynamic flames, smoke, and coordinated human evacuation in a single shot. Cameras are placed at ceiling height to maximize floor coverage, with aliases `ceiling_00` through `ceiling_04`.
+A localized volumetric fire ignites at a randomized position and time while a small crew of workers performs random walks. On ignition, each worker reacts: it orients toward the flame and then runs toward a designated exit waypoint along a navigation-mesh path. The result is rare emergency-response footage that combines dynamic flames, smoke, and coordinated human evacuation in a single shot. Cameras are placed at ceiling height to maximize floor coverage.
 
-![Warehouse fire — full 10-second run, ignition followed by coordinated evacuation, shown across all five modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, Canny edges).](./assets/clip_fire.webp)
+![Warehouse fire — full 10-second run, ignition followed by coordinated evacuation, shown across all 5 modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, canny edges).](./assets/clip_fire.webp)
 
 ### Forklift–shelf collision
 
-A forklift drives at a parameterized initial distance toward a populated storage shelf and impacts it, producing visible rigid-body knock-over and debris dynamics. An optional character can be placed along the forklift's path to extend the scenario to a three-body forklift–shelf–human event. Cameras are placed circularly around the impact site at varying heights, distances, and look-down angles, with aliases `cam_00` through `cam_05`.
+A forklift drives at a parameterized initial distance toward a storage shelf and impacts it, producing visible rigid-body knock-over and debris dynamics. An optional character can be placed along the forklift's path to extend the scenario to a three-body forklift–shelf–human event. Cameras are placed circularly around the impact site at varying heights, distances, and look-down angles.
 
-![Forklift–shelf collision — full 15-second run, drive into the shelf and ensuing debris, shown across all five modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, Canny edges).](./assets/clip_forklift_collision.webp)
+![Forklift–shelf collision — full 15-second run, drive into the shelf and ensuing debris, shown across all 5 modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, canny edges).](./assets/clip_forklift_collision.webp)
 
 ### Warehouse box pickup
 
-A worker navigates to a randomly placed box, performs a contact-rich pickup motion, and carries the box through the warehouse. This scenario provides routine, non-incident action coverage as a counterpoint to the three safety scenarios. The camera rig is a mixed CCTV and eye-level configuration, with aliases `cam_00` through `cam_09`.
+A worker navigates to a randomly placed box, performs a contact-rich pickup motion, and carries the box through the warehouse. This scenario provides routine, non-incident action coverage as a counterpoint to the 3 safety scenarios. The camera rig is a mixed CCTV and eye-level configuration.
 
-![Warehouse box pickup — full 15-second run, walk plus contact-rich pickup plus carry, shown across all five modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, Canny edges).](./assets/clip_box_pickup.webp)
+![Warehouse box pickup — full 15-second run, walk plus contact-rich pickup plus carry, shown across all 5 modalities (left to right: RGB, depth, instance segmentation, shaded segmentation, canny edges).](./assets/clip_box_pickup.webp)
 
 ## Multi-view coverage
 
-Every multi-camera simulation run is captured from five to ten synchronized cameras. For the near-miss scenario, the rig consists of five ceiling-mounted CCTV-style cameras and five worker-height eye-level cameras, all pointed at the interaction. The figure below shows a single near-miss run from each of the ten viewpoints; because all cameras share a clock and the same scene, the same instant in time appears across all ten frames.
+Every multi-camera simulation run is captured from 5 to 10 synchronized cameras. For the near-miss scenario, the rig consists of 5 ceiling-mounted CCTV-style cameras and 5 worker-height eye-level cameras, all pointed at the interaction. The figure below shows a single near-miss run from each of the 10 viewpoints; because all cameras share a clock and the same scene, the same instant in time appears across all 10 frames.
 
-![Multi-view coverage — one near-miss run from ten synchronized cameras: five ceiling and five eye-level.](./assets/multiview_grid.png)
+![Multi-view coverage — one near-miss run from 10 synchronized cameras: 5 ceiling and 5 eye-level.](./assets/multiview_grid.png)
 
-For the fire scenario, the rig is the five ceiling cameras only. For the forklift–shelf collision, six cameras are arranged circularly around the impact site at varying heights and look-down angles. For the box-pickup scenario, the rig is a mixed CCTV plus eye-level configuration with ten cameras.
+For the fire scenario, the rig is 5 ceiling cameras only. For the forklift–shelf collision, 6 cameras are arranged circularly around the impact site at varying heights and look-down angles. For the box-pickup scenario, the rig is a mixed CCTV plus eye-level configuration with 10 cameras.
 
 ## Ground-truth modalities
 
-The synthetic origin of the dataset gives us access to deterministic, perfectly-aligned ground truth for every frame, rendered directly by the simulator rather than predicted by a model. The per-scenario animations above show, alongside the photoreal RGB video, the four annotation modalities that are visible as imagery: log-normalized colorized metric depth, instance segmentation (colorized so the per-pixel identity is visible), shaded segmentation (the same per-pixel identity rendered with normal-based shading), and a Canny edge map computed on the shaded segmentation. Because all five modalities are produced by the same simulator step from the same camera, they are pixel-aligned across every frame.
+The synthetic origin of the dataset gives us access to deterministic, pixel-aligned ground truth for every frame, rendered directly by the simulator. 4 annotation modalities are exported as video alongside each RGB clip:
+
+- **Depth** (`depth.mp4`): log-normalized colorized metric depth. Each pixel's color encodes the absolute distance from the camera in metres, convertible to a full depth map using the per-frame camera intrinsics.
+- **Instance segmentation** (`segmentation.mp4`): each pixel is colorized by its instance ID, so every distinct agent and prop in the scene has a unique, consistent color across all frames.
+- **Shaded segmentation** (`shaded_seg.mp4`): the same per-pixel instance identity rendered with surface-normal-based shading, preserving object boundaries and surface orientation while keeping per-instance identity visible.
+- **canny edges** (`edges.mp4`): a canny edge map computed on the shaded segmentation, giving clean, noiseless structural outlines.
 
-In addition to the imagery shown above, every frame ships with per-agent two-dimensional axis-aligned bounding boxes (both tight and loose), per-agent oriented three-dimensional bounding boxes, and the camera intrinsics and extrinsics that produced the frame. These structured annotations live in the per-camera consolidated `camera_params.jsonl` and `object_detection.jsonl` files in the artifacts tier.
+In addition, every run ships 2 types of structured per-frame annotations per camera:
 
-The artifacts tier publishes the four modality videos shown above (`depth.mp4`, `segmentation.mp4`, `shaded_seg.mp4`, and `edges.mp4`), the per-camera compressed NPZ holding the raw integer-id instance-segmentation arrays (the underlying ground-truth identities), the per-camera consolidated `camera_params.jsonl` and `object_detection.jsonl` files, and a copy of the per-camera `rgb.mp4` so that the artifacts tier is self-contained. Shard keys are designed so that the RGB tier and the artifacts tier join cleanly on the per-sample `run_id`: the run identifier in both tiers is the same string.
+- **`object_detection.jsonl`**: one JSON object per frame (one line per frame). Each object contains a list of detected agents and props, each with a class label, a 2D tight axis-aligned bounding box, a 2D loose axis-aligned bounding box, and an oriented 3D bounding box (center, dimensions, and rotation) in world coordinates.
+- **`camera_params.jsonl`**: one JSON object per frame (one line per frame). Each object contains the camera intrinsics (focal lengths `fx`, `fy`, principal point `cx`, `cy`) and extrinsics (world-to-camera rotation matrix and translation vector), enabling projection between 3D world coordinates and 2D pixel space.
+
+The raw per-pixel instance IDs are also available as a **compressed NumPy archive** (`instance_id_segmentation.npz`) per camera per run, containing 2 arrays:
+
+- `frames`: shape `[T, H, W, 4]`, dtype `uint8`. The 4 channels (RGBA) together encode a 32-bit integer instance ID per pixel (`id = R + G×256 + B×65536 + A×16777216`). An ID of 0 means background. Each unique non-zero ID corresponds to a single tracked agent or prop, consistent across all frames of the run.
+- `frame_indices`: shape `[T]`, dtype `int32`. The original frame numbers from the simulation run, useful when the exported clip is a trimmed or subsampled window of the full simulation.
 
 ## Dataset statistics
 
@@ -127,13 +169,11 @@ The artifacts tier publishes the four modality videos shown above (`depth.mp4`,
 | Warehouse box pickup | 25,677 | 2,601 | 15 seconds | 10 | `rgb/warehouse_box_pickup/` |
 | **Total** | **122,967** | **29,195** | — | — | — |
 
-The aggregate footage is approximately 412 hours at 1920 by 1080 resolution and 30 frames per second. The "Number of runs" column corresponds to distinct WebDataset samples, that is, the number of `__key__` values you will observe when iterating with a WebDataset reader. A small portion of the near-miss split (single-camera samples carried over from an earlier pipeline) is flagged in each sample's `meta.json` via a `source_kind` field; both kinds otherwise share the same schema and can be used together or filtered.
-
 ## Simulation pipeline
 
-All four scenarios are built on NVIDIA Isaac Sim. Procedural scene composition — warehouse layout, shelf placement, prop variation, and per-light randomization of color temperature, intensity, exposure, and color — is handled by the Isaac Sim Replicator Object component. Agent and sensor population — worker spawning and behavior, forklift placement and navigation, and the camera rigs that define the dataset's multi-view viewpoints — is handled by the Isaac Sim Replicator Agent component. Camera placement is parametric, with height, distance, and look-down angle sampled per run. Worker assets and motions are sampled from Isaac Sim's character library to diversify human appearance and gait.
+All 4 scenarios are built on NVIDIA Isaac Sim. Procedural scene composition — warehouse layout, shelf placement, prop variation, and per-light randomization of color temperature, intensity, exposure, and color — is handled by the Isaac Sim Replicator Object component. Agent and sensor population — worker spawning and behavior, forklift placement and navigation, and the camera rigs that define the dataset's multi-view viewpoints — is handled by the Isaac Sim Replicator Agent component. Camera placement is parametric, with height, distance, and look-down angle sampled per run. Worker assets and motions are sampled from Isaac Sim's character library to diversify human appearance and gait.
 
-Each simulation run is seeded with a unique random seed that controls every randomized variable: scene composition, lighting, agent identity, agent motion, camera pose, and event timing. The seed is exposed in each sample's `meta.json` (and in the Parquet indexes), so any individual run is fully reproducible from this dataset alone, and the same pipeline can be extended to additional scenarios outside this release without modification.
+Each simulation run is seeded with a unique random seed that controls every randomized variable: scene composition, lighting, agent identity, agent motion, camera pose, and event timing. The seed is recorded in the Parquet indexes (and inside each shard's `meta.json`), so any individual run is fully reproducible from this dataset alone, and the same pipeline can be extended to additional scenarios outside this release without modification.
 
 ## Repository layout
 
@@ -149,18 +189,18 @@ nvidia/PhysicalAI-SDG-WareHouse/
 │   │                             camera_alias, source_rgb_s3, size, etc.
 │   └── manifests/              ← provenance copies of the source-S3 manifests
 ├── rgb/                        ← RGB tier (~2.24 TiB)
-│   ├── forklift_human_nearmiss/    (113 shards, ~5 GiB each)
+│   ├── forklift_human_nearmiss/    (113 shards, ~5GBs each)
 │   ├── warehouse_fire/             (125 shards)
 │   ├── forklift_shelf_collision/   (114 shards)
 │   └── warehouse_box_pickup/       (107 shards)
 └── artifacts/                  ← artifacts tier (~13 TiB)
-    ├── forklift_human_nearmiss/    (547 shards, ~5 GiB each)
+    ├── forklift_human_nearmiss/    (547 shards, ~5GBs each)
     ├── warehouse_fire/             (~470 shards)
     ├── forklift_shelf_collision/   (~820 shards)
     └── warehouse_box_pickup/       (1293 shards)
 ```
 
-Each `.tar` is a WebDataset archive. The two tiers share the same `__key__` (the `run_id`) so that joining them only requires opening the corresponding shard in each tier.
+Each `.tar` is a WebDataset archive. The 2 tiers share the same `__key__` (the `run_id`) so that joining them only requires opening the corresponding shard in each tier.
 
 **RGB tier sample.** Every sample is a group of entries that share the run_id stem, plus one MP4 per camera:
 
@@ -173,7 +213,7 @@ fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_01.rgb.mp4
 fd7cc35596b247b16b0b_run_8_seed_864110064.eye_04.rgb.mp4
 ```
 
-**Artifacts tier sample.** Same `__key__`. Per camera, the tier ships the modality MP4s, the consolidated integer-id NPZ, and the two consolidated JSONL files; the RGB MP4 is repeated so each artifacts shard is self-contained:
+**Artifacts tier sample.** Same `__key__`. Per camera, the tier ships the modality MP4s, the consolidated integer-id NPZ, and the 2 consolidated JSONL files; the RGB MP4 is repeated so each artifacts shard is self-contained:
 
 ```
 fd7cc35596b247b16b0b_run_8_seed_864110064.meta.json
@@ -188,9 +228,7 @@ fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.object_detection.jsonl
 … (repeated for each camera)
 ```
 
-Each NPZ contains two arrays: `frames` of shape `[T, H, W, 4]` (uint8 RGBA, where the four channels together encode the integer instance id) and `frame_indices` of shape `[T]` (int32). The JSONL files are one JSON object per frame.
-
-WebDataset readers yield one Python dictionary per run. For the RGB tier the dictionary has `__key__`, `meta.json`, `metadata.txt`, and one `{camera_alias}.rgb.mp4` per camera. For the artifacts tier the dictionary additionally has the four modality MP4s, the NPZ, and the two JSONL files per camera.
+WebDataset readers yield one Python dictionary per run. For the RGB tier the dictionary has `__key__`, `meta.json`, `metadata.txt`, and one `{camera_alias}.rgb.mp4` per camera. For the artifacts tier the dictionary additionally has the 4 modality MP4s, the NPZ, and the 2 JSONL files per camera.
 
 ## Loading examples
 
@@ -223,7 +261,7 @@ for sample in dataset.shuffle(1000):
 
 ### Filter with the Parquet index, then fetch only the shards you need
 
-The Parquet indexes let you select clips or runs by any combination of scenario, camera alias, source kind, or seed, and recover the exact shard paths to fetch.
+`metadata/runs.parquet` contains one row per simulation run, with columns `scenario`, `seed`, `source_kind`, `n_cameras`, `total_bytes`, `shard_path_in_repo`, and `clip_keys`. `metadata/clips.parquet` contains one row per camera-clip, with columns `scenario`, `camera_alias`, `seed`, `source_kind`, `shard_path_in_repo`, `hash_filename`, and `size`. Use these indexes to select exactly the runs or clips you need and retrieve only the relevant shard files, without downloading the full dataset.
 
 ```python
 import pandas as pd
@@ -237,10 +275,13 @@ clips = pd.read_parquet(
     )
 )
 
-# All eye-level views from fire runs with an even seed:
+# Inspect available scenario names:
+# print(clips.scenario.unique())
+
+# All ceiling-camera views from near-miss runs with an even seed:
 selection = clips[
-    (clips.scenario == "fire")
-    & (clips.camera_alias.str.startswith("eye_"))
+    (clips.scenario == "forklift_human_nearmiss")
+    & (clips.camera_alias.str.startswith("ceiling_"))
     & (clips.seed.notna()) & (clips.seed % 2 == 0)
 ]
 unique_shards = sorted(selection.shard_path_in_repo.unique())
@@ -258,7 +299,7 @@ huggingface-cli download nvidia/PhysicalAI-SDG-WareHouse \
   --local-dir ./PhysicalAI-SDG-WareHouse
 ```
 
-To pull RGB plus the matching artifacts (depth, segmentation, shaded segmentation, Canny edges, instance-id NPZ, and per-frame camera and bounding-box JSONL):
+To pull RGB plus the matching artifacts (depth, segmentation, shaded segmentation, canny edges, instance-id NPZ, and per-frame camera and bounding-box JSONL):
 
 ```bash
 huggingface-cli download nvidia/PhysicalAI-SDG-WareHouse \
@@ -286,69 +327,6 @@ local_artifacts = hf_hub_download(
 )
 ```
 
-### Join the RGB tier and the artifacts tier on `run_id`
-
-The two tiers share the per-sample `__key__`, so joining them in a streaming loop is a single `select` step:
-
-```python
-import io, json
-import numpy as np
-import webdataset as wds
-
-rgb_url       = "pipe:curl -s -L 'https://huggingface.co/datasets/nvidia/PhysicalAI-SDG-WareHouse/resolve/main/rgb/forklift_human_nearmiss/nearmiss-rgb-00000.tar'"
-artifacts_url = "pipe:curl -s -L 'https://huggingface.co/datasets/nvidia/PhysicalAI-SDG-WareHouse/resolve/main/artifacts/forklift_human_nearmiss/nearmiss-artifacts-00000.tar'"
-
-rgb_ds       = wds.WebDataset(rgb_url).decode()
-artifacts_ds = wds.WebDataset(artifacts_url).decode()
-
-rgb_by_key = {s["__key__"]: s for s in rgb_ds}
-for art in artifacts_ds:
-    key = art["__key__"]
-    if key not in rgb_by_key:
-        continue
-    rgb_mp4   = rgb_by_key[key]["ceiling_00.rgb.mp4"]      # bytes
-    depth_mp4 = art["ceiling_00.depth.mp4"]                # bytes
-    inst_npz  = np.load(io.BytesIO(art["ceiling_00.instance_id_segmentation.npz"]))
-    bboxes    = [json.loads(line) for line in art["ceiling_00.object_detection.jsonl"].splitlines()]
-    print(key, inst_npz["frames"].shape, len(bboxes))
-    break
-```
-
-## Dataset description (standard form)
-
-**Dataset description.** PhysicalAI SDG-Warehouse is a synthetic, fully-annotated multi-view video dataset of staged industrial-safety events captured in a simulated warehouse environment using NVIDIA Isaac Sim. It contains 122,967 video clips drawn from 29,195 distinct multi-camera simulation runs across four scenarios: forklift–human near-miss, warehouse fire with worker evacuation, forklift–shelf collision, and warehouse box pickup. Each run is filmed from five to ten synchronized cameras at 1920 × 1080 resolution and 30 frames per second, and every RGB frame is paired with deterministic ground truth (metric depth, instance and shaded segmentation, Canny edges, 2D and 3D bounding boxes, and per-frame camera intrinsics and extrinsics) rendered natively by the simulator. This dataset is for research and development only.
-
-**Dataset owner(s).** NVIDIA Corporation.
-
-**Dataset creation date.** 2026-05.
-
-**License / terms of use.** Released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license.
-
-**Intended usage.** SDG-Warehouse is intended for research and development of physical-AI models — including but not limited to video understanding (action recognition, anomaly and incident detection, multi-camera person re-identification, worker activity recognition), pixel-level perception (monocular depth estimation, instance segmentation, edge prediction, 2D and 3D object detection and tracking), video generation and world modeling (text-to-video, conditional video generation, long-horizon prediction), and policy or planning research that benefits from controllable, reproducible safety-event footage. It is also a useful resource for studying sim-to-real transfer in warehouse and industrial settings, and as a controlled benchmark for evaluating model robustness across viewpoints, lighting, and agent appearance.
-
-**Dataset characterization.**
-
-- *Data collection method.* Synthetic. All footage was rendered in NVIDIA Isaac Sim using the Isaac Replicator Object and Isaac Replicator Agent components; no real-world footage was captured or used.
-- *Labeling method.* Synthetic / Automated. All ground-truth annotations (depth, segmentation, edges, bounding boxes, camera parameters) are generated by the Isaac Sim Replicator pipeline as a deterministic byproduct of rendering. No human labeling was used.
-
-**Dataset format.**
-
-- *Modalities.* Video (photoreal RGB and four rendered annotation modalities — colorized metric depth, colorized instance segmentation, shaded segmentation, Canny edges), per-frame integer-id instance-segmentation arrays, per-frame structured annotations (2D and 3D bounding boxes, camera intrinsics and extrinsics).
-- *Container and codec.* MP4 (H.264) at 1920 × 1080, 30 fps, for both RGB and annotation videos.
-- *Structured annotations.* JSON Lines (one JSON object per frame), consolidated per camera per run into `camera_params.jsonl` and `object_detection.jsonl`.
-- *Raw instance ids.* NumPy compressed archive (`.npz`), one per camera per run, containing `frames` (`uint8[T, H, W, 4]`, the four channels encoding the integer id) and `frame_indices` (`int32[T]`).
-- *Run-level metadata.* JSON (`meta.json`) and plain text (`metadata.txt`).
-- *Packaging.* [WebDataset](https://github.com/webdataset/webdataset) tar shards, approximately 5 GiB each, with one WebDataset sample per simulation run.
-- *Indexes.* Apache Parquet, one row per run and one row per camera-clip.
-
-**Dataset quantification.**
-
-- *Record count.* 122,967 camera-clips drawn from 29,195 multi-camera simulation runs (WebDataset samples). Aggregate footage is approximately 412 hours.
-- *Feature count.* Per camera-clip, the dataset provides 5 video modalities (RGB, depth, instance segmentation, shaded segmentation, Canny edges), 1 raw integer-id NPZ, and 2 structured-annotation JSONL files; per frame, the structured annotations contain 2D bounding boxes (both tight and loose axis-aligned), 3D oriented bounding boxes, and full camera intrinsics and extrinsics.
-- *Total data storage.* Approximately 15.2 tebibytes: the RGB tier is approximately 2.24 tebibytes (459 shards) and the artifacts tier is approximately 13 tebibytes (~3,130 shards).
-
-**Reference(s).** Cosmos3 technical report, Appendix A.1.5 — see [Citation](#citation).
-
 ## Known limitations and future work
 
 The dataset is fully synthetic and exhibits a sim-to-real gap. Compared to real warehouse footage, the rendered material can have a computer-graphics-like appearance, simplified material response, and limited fidelity in volumetric effects such as smoke and fire. Models trained on the dataset should be carefully evaluated on real footage before being deployed in any safety-critical setting.