Update dataset card: artifacts tier published; align with NVIDIA standard description sections

README.md

@@ -30,15 +30,18 @@ tags:
 
 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.
 
-This dataset is described in Appendix A.1.5 of the Cosmos3 technical report (citation [below](#citation)).
+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.
 
-This first release publishes the RGB video tier. A companion artifacts tier containing the full annotation stack — metric depth, instance and shaded segmentation, Canny edges, two-dimensional and three-dimensional bounding boxes, and per-frame camera intrinsics and extrinsics — is rendered natively by Isaac Sim and pixel-aligned to every RGB frame; it will land in an `artifacts/` directory of this same repository as a follow-up. The annotation visualizations later on this page show those native renders.
+The dataset is published in two complementary tiers under the same repository, joinable per-sample on `run_id`:
 
-The RGB tier consists of 459 WebDataset shards totaling approximately 2.24 tebibytes of video, plus two small Parquet indexes (one row per run and one row per camera-clip) that enable filtering by scenario, seed, camera, or source without opening a single shard.
+- 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.
+
+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.
 
 ## Why this dataset
 
@@ -48,7 +51,7 @@ We therefore generate the dataset in simulation. In a simulator, the event is gu
 
 ## Quickstart
 
-Download a single scenario, which is the recommended starting point for most users since each scenario 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 gigabytes:
 
 ```bash
 pip install -U "huggingface_hub[hf_xet]"
@@ -59,16 +62,16 @@ huggingface-cli download nvidia/PhysicalAI-SDG-WareHouse \
   --local-dir ./PhysicalAI-SDG-WareHouse
 ```
 
-The available scenario directories are summarized below.
+The RGB and artifact tiers per scenario are summarized below.
 
-| Scenario | Repository path | Shards | Approximate size |
-|---|---|---:|---:|
-| Forklift–human near-miss | `rgb/forklift_human_nearmiss/` | 113 | 549 GiB |
-| Warehouse fire | `rgb/warehouse_fire/` | 125 | 619 GiB |
-| Forklift–shelf collision | `rgb/forklift_shelf_collision/` | 114 | 559 GiB |
-| Warehouse box pickup | `rgb/warehouse_box_pickup/` | 107 | 520 GiB |
+| Scenario | RGB path | RGB shards | RGB size | Artifacts path | Artifact shards | Artifact size |
+|---|---|---:|---:|---|---:|---:|
+| Forklift–human near-miss | `rgb/forklift_human_nearmiss/` | 113 | 549 GiB | `artifacts/forklift_human_nearmiss/` | 547 | 2.46 TiB |
+| Warehouse fire | `rgb/warehouse_fire/` | 125 | 619 GiB | `artifacts/warehouse_fire/` | ~470 | ~2.1 TiB |
+| 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 |
 
-To pull the full dataset (approximately 2.24 tebibytes), omit the `--include` filter. For streaming pipelines that never materialize the data on disk, see [Loading examples](#loading-examples).
+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).
 
 ## Scenarios
 
@@ -110,9 +113,9 @@ For the fire scenario, the rig is the five ceiling cameras only. For the forklif
 
 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.
 
-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 per-camera consolidated JSON files in the upcoming artifacts tier.
+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.
 
-The current RGB tier publishes the photoreal RGB video and the run-level metadata. The artifacts tier publishes the four modality videos shown above (`depth.mp4`, `segmentation.mp4`, `shaded_seg.mp4`, and `edges.mp4`), the per-frame raw instance-segmentation PNGs that contain the underlying integer identities, the per-camera consolidated `camera_params.json` and `object_detection.json` files, and the run-level IRO randomization configuration. The shard keys are designed so that the RGB tier and the artifacts tier join cleanly on the per-sample `run_id`.
+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.
 
 ## Dataset statistics
 
@@ -145,31 +148,49 @@ nvidia/PhysicalAI-SDG-WareHouse/
 │   ├── clips.parquet           ← one row per (run × camera), with hash_filename,
 │   │                             camera_alias, source_rgb_s3, size, etc.
 │   └── manifests/              ← provenance copies of the source-S3 manifests
-└── rgb/                        ← this release
-    ├── forklift_human_nearmiss/
-    │   ├── nearmiss-rgb-00000.tar
-    │   ├── nearmiss-rgb-00001.tar
-    │   └── …                   (113 shards, ~5 GiB each)
-    ├── warehouse_fire/         (125 shards)
-    ├── forklift_shelf_collision/   (114 shards)
-    └── warehouse_box_pickup/   (107 shards)
+├── rgb/                        ← RGB tier (~2.24 TiB)
+│   ├── forklift_human_nearmiss/    (113 shards, ~5 GiB 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)
+    ├── warehouse_fire/             (~470 shards)
+    ├── forklift_shelf_collision/   (~820 shards)
+    └── warehouse_box_pickup/       (1293 shards)
 ```
 
-Each `.tar` is a WebDataset archive. Inside it, every sample is a group of entries that share the same stem, where the stem is the `run_id`:
+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.
+
+**RGB tier sample.** Every sample is a group of entries that share the run_id stem, plus one MP4 per camera:
 
 ```
 fd7cc35596b247b16b0b_run_8_seed_864110064.meta.json
 fd7cc35596b247b16b0b_run_8_seed_864110064.metadata.txt
 fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.rgb.mp4
 fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_01.rgb.mp4
-fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_02.rgb.mp4
-fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_03.rgb.mp4
-fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_04.rgb.mp4
-fd7cc35596b247b16b0b_run_8_seed_864110064.eye_00.rgb.mp4
 …
+fd7cc35596b247b16b0b_run_8_seed_864110064.eye_04.rgb.mp4
 ```
 
-WebDataset readers yield one Python dictionary per run, with `__key__` set to the `run_id`, a `meta.json` entry, an optional `metadata.txt` entry, and one `{camera_alias}.rgb.mp4` entry per camera.
+**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:
+
+```
+fd7cc35596b247b16b0b_run_8_seed_864110064.meta.json
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.rgb.mp4
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.depth.mp4
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.segmentation.mp4
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.shaded_seg.mp4
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.edges.mp4
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.instance_id_segmentation.npz
+fd7cc35596b247b16b0b_run_8_seed_864110064.ceiling_00.camera_params.jsonl
+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.
 
 ## Loading examples
 
@@ -228,6 +249,8 @@ print(f"{len(selection):,} clips across {len(unique_shards)} shards")
 
 ### Pull one scenario only with the CLI
 
+To pull RGB only:
+
 ```bash
 huggingface-cli download nvidia/PhysicalAI-SDG-WareHouse \
   --repo-type dataset \
@@ -235,36 +258,98 @@ 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):
+
+```bash
+huggingface-cli download nvidia/PhysicalAI-SDG-WareHouse \
+  --repo-type dataset \
+  --include "rgb/warehouse_box_pickup/**" \
+            "artifacts/warehouse_box_pickup/**" \
+            "metadata/**" \
+  --local-dir ./PhysicalAI-SDG-WareHouse
+```
+
 ### Pull a single shard programmatically
 
 ```python
 from huggingface_hub import hf_hub_download
 
-local_tar = hf_hub_download(
+local_rgb = hf_hub_download(
     repo_id="nvidia/PhysicalAI-SDG-WareHouse",
     repo_type="dataset",
     filename="rgb/forklift_human_nearmiss/nearmiss-rgb-00000.tar",
 )
+local_artifacts = hf_hub_download(
+    repo_id="nvidia/PhysicalAI-SDG-WareHouse",
+    repo_type="dataset",
+    filename="artifacts/forklift_human_nearmiss/nearmiss-artifacts-00000.tar",
+)
 ```
 
-## Dataset description
-
-| Field | Value |
-|---|---|
-| Owner | NVIDIA |
-| Creation date | 2026 |
-| Data collection method | Synthetic (NVIDIA Isaac Sim, with the Isaac Replicator Object and Isaac Replicator Agent components) |
-| Labeling method | Automatic (Isaac Sim Replicator) |
-| Container and codec | MP4 (H.264) |
-| Resolution | 1920 × 1080 |
-| Frame rate | 30 frames per second |
-| Packaging | WebDataset tar shards, approximately 5 GiB each |
-| Metadata language | English |
-| License | CC BY 4.0 |
+### Join the RGB tier and the artifacts tier on `run_id`
 
-## Known limitations and future work
+The two tiers share the per-sample `__key__`, so joining them in a streaming loop is a single `select` step:
 
-This release publishes the RGB tier only. The full annotation stack — metric depth, instance and shaded segmentation, Canny edges, two-dimensional and three-dimensional bounding boxes, and per-frame camera intrinsics and extrinsics — is already rendered, aligned to every RGB frame, and will be added to this same repository as a companion `artifacts/` tier. The visualizations in the ground-truth modalities figure above were produced from those native renders.
+```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.
 
@@ -290,14 +375,10 @@ If you use SDG-Warehouse in your research, please cite the Cosmos3 technical rep
 }
 ```
 
-## License
-
-Released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license.
-
 ## Ethical considerations
 
 NVIDIA believes trustworthy AI is a shared responsibility, and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal model team to ensure this dataset meets the requirements for their relevant industry and use case, and addresses any unforeseen product misuse.
 
 SDG-Warehouse is fully synthetic. It contains no real people, no real workplaces, and no real surveillance footage, and it depicts safety-critical events — near-misses, collisions, fires, and evacuations — only in simulation. Models trained on it should still be carefully evaluated on real footage before being deployed in any safety-critical setting, and operators should be aware of the sim-to-real gap noted above.
 
-Please report security vulnerabilities or NVIDIA AI concerns [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/).
+Please report quality, risk, security vulnerabilities, or NVIDIA AI concerns [here](https://www.nvidia.com/en-us/support/submit-security-vulnerability/).