Release nuScenes-NRS v1.0.0 archive package

CITATION.cff

@@ -0,0 +1,30 @@
+cff-version: 1.2.0
+message: "If you use nuScenes-NRS, please cite this dataset release and the IAF-Net paper."
+title: "nuScenes-NRS: Derived Road-Segmentation Masks"
+version: 1.0.0
+date-released: 2026-08-10
+# `other` is intentional: the derived files follow CC BY-NC-SA 4.0 together
+# with the additional nuScenes Dataset Terms; the accompanying scripts are
+# MIT-licensed separately (see LICENSE_DATA.md).
+license: other
+authors:
+  - family-names: Wang
+    given-names: Bingtao
+  - family-names: Peng
+    given-names: Daojie
+  - family-names: Ma
+    given-names: Fulong
+  - family-names: Ma
+    given-names: Jun
+  - family-names: Zhang
+    given-names: Liang
+url: https://huggingface.co/datasets/PeterNano/nuScenes-NRS
+keywords:
+  - autonomous driving
+  - road segmentation
+  - low-light perception
+  - nuScenes
+abstract: >-
+  Derived front-camera road masks and scene-disjoint token splits for the
+  nuScenes-NRS low-light road-segmentation benchmark. Original nuScenes
+  sensor data are not redistributed.

LICENSE_DATA.md

@@ -0,0 +1,73 @@
+# Data-use terms for nuScenes-NRS derived artifacts
+
+This file is a release notice, not a replacement for the official nuScenes
+agreement. The official agreement is the controlling text:
+
+* [nuScenes Terms of Use](https://www.nuscenes.org/terms-of-use)
+  (non-commercial terms, last updated by Motional on 16 November 2021); and
+* [CC BY-NC-SA 4.0 legal code](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+
+The official terms expressly cover use of data derived from nuScenes. They
+apply in addition to the conditions below, and prevail if there is any
+conflict.
+
+## Scope
+
+These terms apply only to the files in this repository that were produced for
+nuScenes-NRS: the PNG road masks, split/token lists, manifests, and related
+documentation. They do not apply to the original nuScenes dataset, which is
+not included here and remains governed by the terms published by the nuScenes
+authors.
+
+## Permission for the derived release
+
+Subject to the official nuScenes terms and the third-party restrictions below,
+the derived masks and split metadata may be downloaded, copied, modified, and
+used for non-commercial academic research, teaching, and evaluation, provided
+that users:
+
+1. retain this notice and the attribution in `CITATION.cff`;
+2. identify modifications to the derived masks or split files; and
+3. do not present the masks as the original nuScenes annotations.
+
+Commercial use, resale, or redistribution as part of a commercial dataset or
+product is not permitted by the non-commercial terms; obtain the appropriate
+commercial license from Motional before such use. This repository does not
+grant a commercial exception.
+
+## Third-party data boundary
+
+No original RGB image, LiDAR point cloud, lidarseg file, calibration, pose,
+depth, or normal file is licensed or redistributed by this repository. A user
+who regenerates masks must independently download nuScenes, satisfy its
+license and attribution requirements, and comply with any applicable
+data-protection or export rules. Some third-party data in nuScenes may carry
+separate restrictions and may not be redistributed. Motional's names,
+trademarks, logos, and endorsement are not granted by this release.
+
+## Scripts
+
+Unless a file states otherwise, the scripts in `scripts/` are released under
+the MIT License:
+
+```text
+Copyright (c) 2026 IAF-Net authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

README.md

@@ -1,3 +1,185 @@
 ---
-{}
----
+pretty_name: nuScenes-NRS
+description: Derived front-camera road-segmentation masks for the low-light nuScenes-NRS benchmark.
+language:
+- en
+# The mask release is a derived artifact and remains subject to the
+# nuScenes Dataset Terms; see the license notice below.
+license: other
+task_categories:
+- image-segmentation
+tags:
+- autonomous-driving
+- road-segmentation
+- low-light-perception
+- nuscenes
+size_categories:
+- 1K<n<10K
+---
+
+# nuScenes-NRS
+
+nuScenes-NRS (nuScenes Nighttime Road Segmentation) is the road-segmentation
+label release used by **IAF-Net: Illumination-Adaptive Fusion for Low-Light
+Urban Road Segmentation**. This repository contains the derived labels and
+the information needed to reproduce them from an authorized copy of the
+official nuScenes data.
+
+## What is included
+
+| split | scenes | masks | mask resolution | distribution |
+|---|---:|---:|---|---|
+| training | 79 | 3,182 | 1600 x 900 | `training/masks.zip` |
+| validation | 20 | 805 | 1600 x 900 | `validation/masks.zip` |
+| **total** | **99** | **3,987** | | |
+
+The split files contain one nuScenes `sample` token per line. Each archive
+contains a `masks/` directory with files named `<sample-token>.png`; a mask
+corresponds to the `CAM_FRONT` key frame of that sample. The training and
+validation scene sets are disjoint. The release contains **no** RGB images,
+LiDAR point clouds, lidarseg files, depth maps, normal maps, calibration
+files, or other raw nuScenes sensor data.
+
+Extract the archives from the repository root before using the validator or a
+loader that expects the unpacked layout:
+
+```bash
+unzip training/masks.zip -d training
+unzip validation/masks.zip -d validation
+```
+
+## Label format
+
+Each file is an 8-bit, three-channel PNG with shape `900 x 1600 x 3` when
+read as RGB:
+
+* road: `R=255, G=0, B=0`;
+* background: `R=G=B=0`.
+
+For a binary mask, use `mask = (rgb[..., 0] > 127)`. When reading with
+OpenCV (`cv2.imread`), the road value is in channel 2 because OpenCV uses
+BGR order. The labels are intentionally stored in the same encoding as the
+training protocol used in IAF-Net.
+
+## Provenance and generation
+
+The labels are projected from the official nuScenes `LIDAR_TOP` point cloud
+and its `lidarseg` labels (class 24, `drivable_surface`) into the official
+`CAM_FRONT` camera. The historical post-processing pipeline is:
+
+1. transform LiDAR points through the calibrated-sensor and ego-pose chains;
+2. retain points in front of the camera and inside the 1600 x 900 image;
+3. Delaunay triangulation with a maximum projected triangle edge of 40 px;
+4. elliptical morphological closing (15 x 15, two iterations);
+5. external-contour Douglas--Peucker approximation (`epsilon = 0.01` of
+   contour perimeter), ignoring contours smaller than 1,000 px;
+6. a final 5 x 5 elliptical erosion (one iteration).
+
+The reference implementation is
+`scripts/generate_masks_from_nuscenes.py`. It writes a three-channel PNG
+with the road in the red channel and never modifies the source dataset.
+Because the original nuScenes files are not redistributed here, exact
+regeneration requires an authorized copy of the same nuScenes trainval and
+lidarseg release.
+
+## Reproduce the masks
+
+Obtain `v1.0-trainval` and the matching `lidarseg` package from the official
+[nuScenes download page](https://www.nuscenes.org/download), and accept the
+nuScenes terms before use. Then install the dependencies:
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+Generate either split (the command below regenerates training; replace the
+split name and file for validation):
+
+```bash
+python scripts/generate_masks_from_nuscenes.py \
+  --dataroot /path/to/nuScenes \
+  --version v1.0-trainval \
+  --split training \
+  --split-file splits/training.txt \
+  --output-root /tmp/nuScenes-NRS-regenerated
+```
+
+The output is written to
+`/tmp/nuScenes-NRS-regenerated/training/masks/`. The script reconstructs the
+official CAM_FRONT/LIDAR_TOP key-frame mapping from `sample_data.json`, checks
+for missing or duplicate records, and reports missing lidarseg files instead
+of silently changing the split.
+
+## Verify a downloaded release
+
+From the repository root, either extract both archives as shown above and run
+the unpacked validator:
+
+```bash
+python scripts/validate_release.py --root .
+```
+
+or verify the archive contents and checksums directly:
+
+```bash
+python scripts/validate_archives.py --root .
+```
+
+The checks cover split counts, filename/token consistency, PNG shape, dtype,
+channel encoding, duplicate tokens, scene disjointness (when official
+metadata is supplied), archive contents, and the recorded SHA-256 manifest.
+
+## Download
+
+The repository is public at
+<https://huggingface.co/datasets/PeterNano/nuScenes-NRS>. For a command-line
+download:
+
+```bash
+pip install -U huggingface_hub
+hf download PeterNano/nuScenes-NRS \
+  --repo-type dataset --local-dir nuScenes-NRS
+```
+
+Older `huggingface_hub` versions expose the same command as
+`huggingface-cli download`.
+
+## License and data-use notice
+
+This repository deliberately redistributes only derived masks, split/token
+metadata, documentation, and scripts. It does **not** redistribute any
+original nuScenes sensor or annotation files. The official nuScenes terms
+state that use of the dataset and of data derived from it is governed by the
+non-commercial `CC BY-NC-SA 4.0` license together with additional Dataset
+Terms; where the two texts conflict, the Dataset Terms prevail. See the
+[official terms of use](https://www.nuscenes.org/terms-of-use) and the
+[CC BY-NC-SA 4.0 legal code](https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode).
+Users must obtain the original nuScenes release directly and satisfy those
+terms. The masks and split metadata are offered only to the extent permitted
+by those terms, with the additional boundary notes in `LICENSE_DATA.md`.
+The scripts are MIT-licensed independently. No license in this repository
+grants rights to the original nuScenes data, trademarks, or third-party
+components.
+
+The labels are automatically generated from sparse projected LiDAR semantics
+and are not hand-drawn dense annotations. They can contain holes, boundary
+uncertainty, and projection artifacts, especially in very dark or occluded
+regions. They should therefore be used as benchmark labels rather than as a
+survey-grade map of drivable space.
+
+## Citation
+
+If you use nuScenes-NRS or the accompanying masks, please cite the dataset
+record and the IAF-Net paper. A machine-readable entry is provided in
+`CITATION.cff`.
+
+```bibtex
+@misc{wang2026iafnet,
+  title        = {IAF-Net: Illumination-Adaptive Fusion for Low-Light Urban Road Segmentation},
+  author       = {Wang, Bingtao and Peng, Daojie and Ma, Fulong and Ma, Jun and Zhang, Liang},
+  year         = {2026},
+  howpublished = {Hugging Face Dataset Card: PeterNano/nuScenes-NRS},
+  note         = {nuScenes-NRS derived-label release, version 1.0.0}
+}
+```
+

SHA256SUMS.txt

@@ -0,0 +1,15 @@
+f64fceb0b56b091a0cc7bbc7135a213d285b0d7469871b101445f5ba764f683d  CITATION.cff
+94ccdf789cc2526d99c6c738795280d1fa4ee59d3fe70d413fff60b83062ff9a  LICENSE_DATA.md
+4f2c123b3a2c3b4b886c73910ffbf086a5d247e1c0fb0e927c2e32af5af2b803  README.md
+59854984853104df5c353e2f681a15fc7924742f9a2e468c29af248dce45ce03  VERSION
+f41ef70abce4475fabe9742dd8d6b27f819937b070263f063791a1721eb18b80  dataset_manifest.json
+8044ee4f47ab0b34a64f89b5efb07d481245a7980cd9e734037cb967e55755dc  requirements.txt
+b728841a273688a2585dd58534f3a2f1b6f70f4d61938617f1c6d1f3170f4dd6  scripts/build_release_metadata.py
+8413bf8ba8aaa85279480b3c57d1bbbdea7819e459761aef057c665dcba4f5d9  scripts/generate_masks_from_nuscenes.py
+7174c114205c69905cce443fe0850decb5861161bda83efeff5e364267288d79  scripts/validate_archives.py
+d810938613878d0474946fbb26d1b2ecca5f9c49b0c75cb7819f347c7b802485  scripts/validate_release.py
+7996c4d6e05c30cf0f594a32b1d2068e185f775db58005672e02c176e6989868  scripts/write_checksums.py
+a81759c52dcfab1941496259a27a464b3e7c2bc633101fd715e51a8c754ee4cb  splits/training.txt
+4dbd6b4fd6471204fc728c93effbfb9febbcf512b504e8346c1f5dccbc1f5b35  splits/validation.txt
+e24ceef6297e9542efa4257b643a409080acec21dc18e315b5d635f35287bfd6  training/masks.zip
+c060135f2ef8f20359dc8f502071c8051e340cc3a9f136664e64f1e43f90255b  validation/masks.zip

VERSION

@@ -0,0 +1 @@
+1.0.0

dataset_manifest.json

@@ -0,0 +1,182 @@
+{
+  "dataset": "nuScenes-NRS",
+  "release_version": "1.0.0",
+  "source": {
+    "dataset": "nuScenes v1.0-trainval plus the matching lidarseg release",
+    "raw_data_redistributed": false,
+    "camera": "CAM_FRONT",
+    "lidar": "LIDAR_TOP"
+  },
+  "distribution": {
+    "format": "ZIP archives containing masks/<sample-token>.png",
+    "training_archive": "training/masks.zip",
+    "validation_archive": "validation/masks.zip",
+    "unpacked_layout": "training/masks/*.png and validation/masks/*.png"
+  },
+  "mask": {
+    "format": "PNG",
+    "dtype": "uint8",
+    "channels": 3,
+    "resolution": [
+      1600,
+      900
+    ],
+    "encoding_rgb": {
+      "road": [
+        255,
+        0,
+        0
+      ],
+      "background": [
+        0,
+        0,
+        0
+      ]
+    },
+    "filename": "<sample-token>.png"
+  },
+  "generation": {
+    "lidarseg_class": 24,
+    "lidarseg_class_name": "drivable_surface",
+    "projection": "LiDAR_TOP -> ego -> global -> camera ego -> CAM_FRONT",
+    "delaunay_max_edge_px": 40.0,
+    "closing_kernel": [
+      15,
+      15
+    ],
+    "closing_iterations": 2,
+    "douglas_peucker_factor": 0.01,
+    "minimum_contour_area_px": 1000,
+    "erosion_kernel": [
+      5,
+      5
+    ],
+    "erosion_iterations": 1
+  },
+  "splits": {
+    "training": {
+      "mask_count": 3182,
+      "scene_count": 79,
+      "scene_tokens_sha256": "34653c561c01277dab77d306cd5b6b30f8eb43bc997433742d811f718c2959b1",
+      "scene_names": [
+        "scene-0992",
+        "scene-0994",
+        "scene-0995",
+        "scene-0996",
+        "scene-0997",
+        "scene-0998",
+        "scene-0999",
+        "scene-1000",
+        "scene-1001",
+        "scene-1002",
+        "scene-1003",
+        "scene-1004",
+        "scene-1005",
+        "scene-1006",
+        "scene-1007",
+        "scene-1008",
+        "scene-1009",
+        "scene-1010",
+        "scene-1011",
+        "scene-1012",
+        "scene-1013",
+        "scene-1014",
+        "scene-1015",
+        "scene-1016",
+        "scene-1017",
+        "scene-1018",
+        "scene-1019",
+        "scene-1020",
+        "scene-1021",
+        "scene-1022",
+        "scene-1023",
+        "scene-1024",
+        "scene-1025",
+        "scene-1044",
+        "scene-1045",
+        "scene-1046",
+        "scene-1047",
+        "scene-1048",
+        "scene-1049",
+        "scene-1050",
+        "scene-1051",
+        "scene-1052",
+        "scene-1053",
+        "scene-1054",
+        "scene-1055",
+        "scene-1056",
+        "scene-1057",
+        "scene-1058",
+        "scene-1059",
+        "scene-1060",
+        "scene-1061",
+        "scene-1062",
+        "scene-1063",
+        "scene-1064",
+        "scene-1065",
+        "scene-1066",
+        "scene-1067",
+        "scene-1068",
+        "scene-1069",
+        "scene-1070",
+        "scene-1071",
+        "scene-1072",
+        "scene-1073",
+        "scene-1074",
+        "scene-1075",
+        "scene-1076",
+        "scene-1077",
+        "scene-1078",
+        "scene-1079",
+        "scene-1080",
+        "scene-1081",
+        "scene-1082",
+        "scene-1083",
+        "scene-1084",
+        "scene-1085",
+        "scene-1086",
+        "scene-1087",
+        "scene-1088",
+        "scene-1089"
+      ],
+      "token_list": "splits/training.txt",
+      "mask_directory": "training/masks",
+      "token_list_sha256": "a81759c52dcfab1941496259a27a464b3e7c2bc633101fd715e51a8c754ee4cb"
+    },
+    "validation": {
+      "mask_count": 805,
+      "scene_count": 20,
+      "scene_tokens_sha256": "eab20ddb461e4ac410d86196d351e07d6ac6e56ac18dc10af15b6e3d691e62b4",
+      "scene_names": [
+        "scene-1090",
+        "scene-1091",
+        "scene-1092",
+        "scene-1093",
+        "scene-1094",
+        "scene-1095",
+        "scene-1096",
+        "scene-1097",
+        "scene-1098",
+        "scene-1099",
+        "scene-1100",
+        "scene-1101",
+        "scene-1102",
+        "scene-1104",
+        "scene-1105",
+        "scene-1106",
+        "scene-1107",
+        "scene-1108",
+        "scene-1109",
+        "scene-1110"
+      ],
+      "token_list": "splits/validation.txt",
+      "mask_directory": "validation/masks",
+      "token_list_sha256": "4dbd6b4fd6471204fc728c93effbfb9febbcf512b504e8346c1f5dccbc1f5b35"
+    }
+  },
+  "split_policy": {
+    "scene_disjoint": true,
+    "training_scene_count": 79,
+    "validation_scene_count": 20
+  }
+}

requirements.txt

@@ -0,0 +1,4 @@
+numpy>=1.23
+opencv-python>=4.7
+scipy>=1.9
+ijson>=3.2

scripts/build_release_metadata.py

@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+"""Build split lists and a compact manifest for a nuScenes-NRS release.
+
+This maintainer utility reads only the derived mask directories and (optionally)
+the official sample/scene metadata. It never copies or publishes raw nuScenes
+files. The generated files are deterministic when the mask directories and
+metadata are unchanged.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+
+EXPECTED = {"training": 3182, "validation": 805}
+
+
+def load_json(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--release-root", type=Path, required=True)
+    parser.add_argument(
+        "--metadata-dir",
+        type=Path,
+        default=None,
+        help="Optional v1.0-trainval directory containing sample.json and scene.json",
+    )
+    args = parser.parse_args()
+    root = args.release_root.resolve()
+    split_dir = root / "splits"
+    split_dir.mkdir(parents=True, exist_ok=True)
+
+    samples = {}
+    scenes = {}
+    if args.metadata_dir:
+        samples = {row["token"]: row for row in load_json(args.metadata_dir / "sample.json")}
+        scenes = {row["token"]: row for row in load_json(args.metadata_dir / "scene.json")}
+
+    manifest = {
+        "dataset": "nuScenes-NRS",
+        "release_version": "1.0.0",
+        "source": {
+            "dataset": "nuScenes v1.0-trainval plus the matching lidarseg release",
+            "raw_data_redistributed": False,
+            "camera": "CAM_FRONT",
+            "lidar": "LIDAR_TOP",
+        },
+        "mask": {
+            "format": "PNG",
+            "dtype": "uint8",
+            "channels": 3,
+            "resolution": [1600, 900],
+            "encoding_rgb": {"road": [255, 0, 0], "background": [0, 0, 0]},
+            "filename": "<sample-token>.png",
+        },
+        "generation": {
+            "lidarseg_class": 24,
+            "lidarseg_class_name": "drivable_surface",
+            "projection": "LiDAR_TOP -> ego -> global -> camera ego -> CAM_FRONT",
+            "delaunay_max_edge_px": 40.0,
+            "closing_kernel": [15, 15],
+            "closing_iterations": 2,
+            "douglas_peucker_factor": 0.01,
+            "minimum_contour_area_px": 1000,
+            "erosion_kernel": [5, 5],
+            "erosion_iterations": 1,
+        },
+        "splits": {},
+    }
+
+    all_tokens = {}
+    for split, expected in EXPECTED.items():
+        mask_dir = root / split / "masks"
+        files = sorted(mask_dir.glob("*.png"))
+        tokens = [path.stem for path in files]
+        if len(files) != expected:
+            raise SystemExit(f"{split}: expected {expected} masks, found {len(files)}")
+        if len(set(tokens)) != len(tokens):
+            raise SystemExit(f"{split}: duplicate mask tokens")
+        if any(len(token) != 32 for token in tokens):
+            bad = next(token for token in tokens if len(token) != 32)
+            raise SystemExit(f"{split}: non-token filename stem {bad!r}")
+        split_file = split_dir / f"{split}.txt"
+        split_file.write_text("".join(f"{token}\n" for token in tokens), encoding="utf-8")
+        scene_tokens = set()
+        scene_names = set()
+        if samples:
+            missing = [token for token in tokens if token not in samples]
+            if missing:
+                raise SystemExit(f"{split}: {len(missing)} tokens absent from sample.json")
+            scene_tokens = {samples[token]["scene_token"] for token in tokens}
+            scene_names = {scenes[token]["name"] for token in scene_tokens if token in scenes}
+        manifest["splits"][split] = {
+            "mask_count": len(files),
+            "scene_count": len(scene_tokens) if samples else None,
+            "scene_tokens_sha256": hashlib.sha256(
+                "\n".join(sorted(scene_tokens)).encode("utf-8")
+            ).hexdigest()
+            if samples
+            else None,
+            "scene_names": sorted(scene_names) if samples else None,
+            "token_list": f"splits/{split}.txt",
+            "mask_directory": f"{split}/masks",
+            "token_list_sha256": sha256_file(split_file),
+        }
+        for token in tokens:
+            all_tokens.setdefault(token, []).append(split)
+
+    overlap = sorted(token for token, splits in all_tokens.items() if len(splits) > 1)
+    if overlap:
+        raise SystemExit(f"training/validation overlap: {len(overlap)} tokens")
+    if samples:
+        train_scenes = {
+            samples[token]["scene_token"]
+            for token, splits in all_tokens.items()
+            if splits == ["training"]
+        }
+        val_scenes = {
+            samples[token]["scene_token"]
+            for token, splits in all_tokens.items()
+            if splits == ["validation"]
+        }
+        if train_scenes & val_scenes:
+            raise SystemExit("training/validation scene overlap detected")
+        manifest["split_policy"] = {
+            "scene_disjoint": True,
+            "training_scene_count": len(train_scenes),
+            "validation_scene_count": len(val_scenes),
+        }
+    else:
+        manifest["split_policy"] = {"scene_disjoint": None}
+
+    manifest_path = root / "dataset_manifest.json"
+    manifest_path.write_text(
+        json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    print(json.dumps({"release_root": str(root), "manifest": str(manifest_path), "masks": len(all_tokens)}, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

scripts/generate_masks_from_nuscenes.py

@@ -0,0 +1,372 @@
+#!/usr/bin/env python3
+"""Recreate nuScenes-NRS road masks from an authorized nuScenes release.
+
+Only the official nuScenes metadata and sensor files supplied by the user are
+read. The source tree is never modified. The implementation mirrors the
+historical projection/triangulation post-processing used for nuScenes-NRS.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import cv2
+import numpy as np
+from scipy.spatial import Delaunay
+
+try:
+    import ijson  # type: ignore
+except ImportError:  # pragma: no cover - fallback for small metadata exports
+    ijson = None
+
+
+DRIVEABLE_SURFACE_LABEL = 24
+IMAGE_WIDTH = 1600
+IMAGE_HEIGHT = 900
+MAX_EDGE_LENGTH = 40.0
+CLOSE_SIZE = 15
+CLOSE_ITER = 2
+SMOOTH_FACTOR = 0.01
+FINAL_ERODE_SIZE = 5
+FINAL_ERODE_ITER = 1
+
+
+def iter_records(path: Path):
+    """Yield records from a nuScenes JSON array without requiring a huge RAM load."""
+    if ijson is not None:
+        with path.open("rb") as handle:
+            yield from ijson.items(handle, "item")
+        return
+    with path.open("r", encoding="utf-8") as handle:
+        records = json.load(handle)
+    yield from records
+
+
+def load_json(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        return json.load(handle)
+
+
+def selected_records(path: Path, wanted: set[str]) -> dict:
+    found = {}
+    for row in iter_records(path):
+        token = row.get("token")
+        if token in wanted:
+            found[token] = row
+            if len(found) == len(wanted):
+                break
+    missing = wanted - found.keys()
+    if missing:
+        raise RuntimeError(f"{path.name}: missing {len(missing)} requested records")
+    return found
+
+
+SENSOR_CHANNELS = ("CAM_FRONT", "LIDAR_TOP")
+
+
+def _channel_from_filename(filename: str) -> str | None:
+    """Return a nuScenes channel encoded in a sample-data filename.
+
+    Official nuScenes ``sample_data.json`` records do not carry a ``channel``
+    field; their ``samples/`` and ``sweeps/`` paths do.  A few converted
+    metadata exports do add the field, and those are handled by
+    :func:`index_sample_data` before this helper is called.
+    """
+    path_parts = Path(filename).parts
+    for channel in SENSOR_CHANNELS:
+        if channel in path_parts:
+            return channel
+    return None
+
+
+def index_sample_data(metadata: Path, wanted: set[str]) -> tuple[dict, dict]:
+    """Index CAM_FRONT/LIDAR_TOP records for the requested sample tokens.
+
+    The official nuScenes ``sample.json`` table intentionally contains no
+    ``data`` mapping.  That mapping is assembled by the devkit from
+    ``sample_data.json`` and the sensor/calibration tables.  This function
+    performs the same assembly while streaming ``sample_data.json`` so the
+    generator does not need to load that large table into memory.
+
+    Returns ``(records_by_token, channels_by_sample)``.  Each requested sample
+    must have exactly one key-frame record for both channels; missing or
+    duplicate records raise a descriptive ``RuntimeError``.
+    """
+    # calibrated_sensor.json and sensor.json are small (dozens of records), so
+    # loading them once gives us a reliable channel fallback when a converted
+    # filename does not retain the standard ``.../<CHANNEL>/...`` path.
+    calibrated_path = metadata / "calibrated_sensor.json"
+    sensor_path = metadata / "sensor.json"
+    calibrated = {
+        row["token"]: row for row in iter_records(calibrated_path)
+    }
+    sensors = {
+        row["token"]: row for row in iter_records(sensor_path)
+    } if sensor_path.is_file() else {}
+
+    records_by_token = {}
+    channels_by_sample = {token: {} for token in wanted}
+    sample_data_path = metadata / "sample_data.json"
+    for row in iter_records(sample_data_path):
+        sample_token = row.get("sample_token")
+        if sample_token not in wanted:
+            continue
+        # A sample can have many historical sweeps.  Only key-frame records
+        # correspond to the samples listed in sample.json.  Some compact
+        # exports omit is_key_frame; in that case retain the row and let the
+        # channel/duplicate checks below decide.
+        if row.get("is_key_frame") is False:
+            continue
+
+        candidates = []
+        direct_channel = row.get("channel")
+        if direct_channel:
+            candidates.append(str(direct_channel))
+        filename_channel = _channel_from_filename(str(row.get("filename", "")))
+        if filename_channel:
+            candidates.append(filename_channel)
+        calibration = calibrated.get(row.get("calibrated_sensor_token"))
+        if calibration is not None:
+            sensor = sensors.get(calibration.get("sensor_token"))
+            if sensor and sensor.get("channel"):
+                candidates.append(str(sensor["channel"]))
+
+        # Keep the first supported channel, but reject contradictory metadata
+        # instead of silently associating a LiDAR record with the camera.
+        supported = {channel for channel in candidates if channel in SENSOR_CHANNELS}
+        if len(supported) > 1:
+            raise RuntimeError(
+                f"{sample_data_path.name}: conflicting channels for record "
+                f"{row.get('token')}: {sorted(supported)}"
+            )
+        if not supported:
+            continue
+        channel = next(iter(supported))
+        previous_token = channels_by_sample[sample_token].get(channel)
+        if previous_token is not None and previous_token != row.get("token"):
+            raise RuntimeError(
+                f"{sample_data_path.name}: sample {sample_token} has multiple "
+                f"key-frame {channel} records ({previous_token}, {row.get('token')})"
+            )
+        token = row.get("token")
+        if not token:
+            raise RuntimeError(f"{sample_data_path.name}: record has no token")
+        channels_by_sample[sample_token][channel] = token
+        records_by_token[token] = row
+
+    missing = {
+        sample_token: sorted(set(SENSOR_CHANNELS) - set(channels))
+        for sample_token, channels in channels_by_sample.items()
+        if set(channels) != set(SENSOR_CHANNELS)
+    }
+    if missing:
+        preview = ", ".join(
+            f"{token}: {','.join(channels)}" for token, channels in list(missing.items())[:5]
+        )
+        raise RuntimeError(
+            f"{sample_data_path.name}: missing requested key-frame records ({preview})"
+        )
+    return records_by_token, channels_by_sample
+
+
+def quaternion_matrix(rotation) -> np.ndarray:
+    w, x, y, z = [float(value) for value in rotation]
+    norm = w * w + x * x + y * y + z * z
+    if norm < 1e-15:
+        raise ValueError("zero-norm quaternion")
+    s = 2.0 / norm
+    return np.array(
+        [
+            [1 - s * (y * y + z * z), s * (x * y - z * w), s * (x * z + y * w)],
+            [s * (x * y + z * w), 1 - s * (x * x + z * z), s * (y * z - x * w)],
+            [s * (x * z - y * w), s * (y * z + x * w), 1 - s * (x * x + y * y)],
+        ],
+        dtype=np.float64,
+    )
+
+
+def transform_matrix(translation, rotation, inverse=False) -> np.ndarray:
+    matrix = np.eye(4, dtype=np.float64)
+    rotation_matrix = quaternion_matrix(rotation)
+    translation = np.asarray(translation, dtype=np.float64)
+    if inverse:
+        rotation_matrix = rotation_matrix.T
+        matrix[:3, :3] = rotation_matrix
+        matrix[:3, 3] = rotation_matrix @ (-translation)
+    else:
+        matrix[:3, :3] = rotation_matrix
+        matrix[:3, 3] = translation
+    return matrix
+
+
+def filter_triangles(points: np.ndarray, simplices: np.ndarray) -> list[np.ndarray]:
+    triangles = []
+    for simplex in simplices:
+        p0, p1, p2 = points[simplex]
+        if max(
+            np.linalg.norm(p1 - p0),
+            np.linalg.norm(p2 - p1),
+            np.linalg.norm(p0 - p2),
+        ) < MAX_EDGE_LENGTH:
+            triangles.append(np.asarray([p0, p1, p2], dtype=np.int32))
+    return triangles
+
+
+def smooth_mask(mask: np.ndarray) -> np.ndarray:
+    if not np.any(mask):
+        return mask
+    close_kernel = cv2.getStructuringElement(
+        cv2.MORPH_ELLIPSE, (CLOSE_SIZE, CLOSE_SIZE)
+    )
+    closed = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, close_kernel, iterations=CLOSE_ITER)
+    contours, _ = cv2.findContours(closed, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)
+    result = np.zeros_like(mask)
+    for contour in contours:
+        if cv2.contourArea(contour) < 1000:
+            continue
+        epsilon = SMOOTH_FACTOR * cv2.arcLength(contour, True)
+        polygon = cv2.approxPolyDP(contour, epsilon, True)
+        cv2.fillPoly(result, [polygon], 255)
+    erode_kernel = cv2.getStructuringElement(
+        cv2.MORPH_ELLIPSE, (FINAL_ERODE_SIZE, FINAL_ERODE_SIZE)
+    )
+    return cv2.erode(result, erode_kernel, iterations=FINAL_ERODE_ITER)
+
+
+def make_mask(
+    dataroot: Path,
+    version: str,
+    sample: dict,
+    sample_data: dict,
+    sample_channels: dict[str, str],
+    calib: dict,
+    poses: dict,
+) -> np.ndarray:
+    cam_sd = sample_data[sample_channels["CAM_FRONT"]]
+    lidar_sd = sample_data[sample_channels["LIDAR_TOP"]]
+    cam_calib = calib[cam_sd["calibrated_sensor_token"]]
+    lidar_calib = calib[lidar_sd["calibrated_sensor_token"]]
+    cam_pose = poses[cam_sd["ego_pose_token"]]
+    lidar_pose = poses[lidar_sd["ego_pose_token"]]
+
+    lidar_path = dataroot / lidar_sd["filename"]
+    label_path = dataroot / "lidarseg" / version / f"{lidar_sd['token']}_lidarseg.bin"
+    if not lidar_path.is_file():
+        raise FileNotFoundError(lidar_path)
+    if not label_path.is_file():
+        raise FileNotFoundError(label_path)
+
+    points = np.fromfile(lidar_path, dtype=np.float32)
+    if points.size % 5:
+        raise RuntimeError(f"unexpected point record size in {lidar_path}")
+    points = points.reshape((-1, 5))[:, :3]
+    labels = np.fromfile(label_path, dtype=np.uint8)
+    if labels.size != points.shape[0]:
+        raise RuntimeError(f"point/label count mismatch for {sample['token']}")
+    points = points[labels == DRIVEABLE_SURFACE_LABEL]
+
+    lidar_to_camera = (
+        transform_matrix(cam_calib["translation"], cam_calib["rotation"], inverse=True)
+        @ transform_matrix(cam_pose["translation"], cam_pose["rotation"], inverse=True)
+        @ transform_matrix(lidar_pose["translation"], lidar_pose["rotation"])
+        @ transform_matrix(lidar_calib["translation"], lidar_calib["rotation"])
+    )
+    homogeneous = np.column_stack((points, np.ones(len(points), dtype=np.float64)))
+    camera_points = (lidar_to_camera @ homogeneous.T)[:3]
+    valid_depth = camera_points[2] > 0.1
+    camera_points = camera_points[:, valid_depth]
+    intrinsic = np.asarray(cam_calib["camera_intrinsic"], dtype=np.float64)
+    projected = intrinsic @ camera_points
+    if projected.shape[1]:
+        projected[:2] /= projected[2:3]
+    inside = (
+        (projected[0] >= 0)
+        & (projected[0] < IMAGE_WIDTH)
+        & (projected[1] >= 0)
+        & (projected[1] < IMAGE_HEIGHT)
+    ) if projected.shape[1] else np.zeros(0, dtype=bool)
+    points_2d = projected[:2, inside].T.astype(np.float32)
+
+    mask = np.zeros((IMAGE_HEIGHT, IMAGE_WIDTH), dtype=np.uint8)
+    if len(points_2d) >= 3:
+        try:
+            triangulation = Delaunay(points_2d)
+            for triangle in filter_triangles(points_2d, triangulation.simplices):
+                cv2.fillPoly(mask, [triangle], 255)
+        except Exception:
+            # Degenerate projected point sets produce an empty raw mask in the
+            # historical implementation; retain that deterministic behavior.
+            pass
+    mask = smooth_mask(mask)
+    rgb = np.zeros((IMAGE_HEIGHT, IMAGE_WIDTH, 3), dtype=np.uint8)
+    rgb[:, :, 2] = mask  # cv2 writes BGR; channel 2 is R in the PNG.
+    return rgb
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--dataroot", type=Path, required=True)
+    parser.add_argument("--version", default="v1.0-trainval")
+    parser.add_argument("--split", choices=("training", "validation"), required=True)
+    parser.add_argument("--split-file", type=Path, required=True)
+    parser.add_argument("--output-root", type=Path, required=True)
+    parser.add_argument("--overwrite", action="store_true")
+    args = parser.parse_args()
+
+    dataroot = args.dataroot.resolve()
+    metadata = dataroot / args.version
+    split_file = args.split_file.resolve()
+    tokens = [line.strip() for line in split_file.read_text(encoding="utf-8").splitlines() if line.strip()]
+    if len(tokens) != len(set(tokens)):
+        raise SystemExit("split file contains duplicate tokens")
+    samples = {row["token"]: row for row in load_json(metadata / "sample.json")}
+    missing_samples = [token for token in tokens if token not in samples]
+    if missing_samples:
+        raise SystemExit(f"{len(missing_samples)} split tokens are absent from sample.json")
+    sample_data, sample_channels_by_sample = index_sample_data(metadata, set(tokens))
+    sample_data_tokens = set(sample_data)
+    calib_tokens = {
+        sample_data[token]["calibrated_sensor_token"] for token in sample_data_tokens
+    }
+    pose_tokens = {sample_data[token]["ego_pose_token"] for token in sample_data_tokens}
+    calib = selected_records(metadata / "calibrated_sensor.json", calib_tokens)
+    poses = selected_records(metadata / "ego_pose.json", pose_tokens)
+
+    out_dir = args.output_root.resolve() / args.split / "masks"
+    out_dir.mkdir(parents=True, exist_ok=True)
+    failures = []
+    for index, token in enumerate(tokens, start=1):
+        output = out_dir / f"{token}.png"
+        if output.exists() and not args.overwrite:
+            continue
+        try:
+            image = make_mask(
+                dataroot,
+                args.version,
+                samples[token],
+                sample_data,
+                sample_channels_by_sample[token],
+                calib,
+                poses,
+            )
+            if not cv2.imwrite(str(output), image):
+                raise OSError(f"cv2.imwrite failed for {output}")
+        except Exception as exc:  # keep all missing records visible to the user
+            failures.append((token, repr(exc)))
+        if index % 100 == 0 or index == len(tokens):
+            print(f"{args.split}: {index}/{len(tokens)}")
+    if failures:
+        for token, error in failures[:20]:
+            print(f"FAIL {token}: {error}")
+        raise SystemExit(f"generation failed for {len(failures)} samples")
+    produced = sorted(path.stem for path in out_dir.glob("*.png"))
+    if produced != sorted(tokens):
+        raise SystemExit(f"output token set differs from split ({len(produced)} files)")
+    print(f"wrote {len(produced)} masks to {out_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/validate_archives.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Validate the archive-based Hugging Face nuScenes-NRS release."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import re
+import zipfile
+from pathlib import Path
+
+import cv2
+import numpy as np
+
+
+EXPECTED = {"training": 3182, "validation": 805}
+TOKEN_RE = re.compile(r"^[0-9a-f]{32}$")
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def read_tokens(path: Path) -> list[str]:
+    tokens = [line.strip() for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    if len(tokens) != len(set(tokens)) or any(not TOKEN_RE.fullmatch(t) for t in tokens):
+        raise AssertionError(f"invalid or duplicate tokens in {path}")
+    return tokens
+
+
+def validate_split(root: Path, split: str) -> list[str]:
+    tokens = read_tokens(root / "splits" / f"{split}.txt")
+    if len(tokens) != EXPECTED[split]:
+        raise AssertionError(f"{split}: expected {EXPECTED[split]}, found {len(tokens)}")
+    archive = root / split / "masks.zip"
+    if not archive.is_file():
+        raise AssertionError(f"missing {archive}")
+    expected_names = {f"masks/{token}.png" for token in tokens}
+    with zipfile.ZipFile(archive) as bundle:
+        names = {name for name in bundle.namelist() if not name.endswith("/")}
+        if names != expected_names:
+            missing = len(expected_names - names)
+            extra = len(names - expected_names)
+            raise AssertionError(f"{split}: archive members differ (missing={missing}, extra={extra})")
+        for index, token in enumerate(tokens, start=1):
+            payload = bundle.read(f"masks/{token}.png")
+            image = cv2.imdecode(np.frombuffer(payload, dtype=np.uint8), cv2.IMREAD_COLOR)
+            if image is None or image.shape != (900, 1600, 3) or image.dtype.name != "uint8":
+                raise AssertionError(f"bad PNG shape/dtype for {split}/{token}.png")
+            if (image[:, :, 0] != 0).any() or (image[:, :, 1] != 0).any():
+                raise AssertionError(f"nonzero blue/green channel for {split}/{token}.png")
+            if not ((image[:, :, 2] == 0) | (image[:, :, 2] == 255)).all():
+                raise AssertionError(f"non-binary red channel for {split}/{token}.png")
+            if index % 500 == 0 or index == len(tokens):
+                print(f"checked {split}: {index}/{len(tokens)}")
+    return tokens
+
+
+def validate_hashes(root: Path) -> None:
+    rows = []
+    for line in (root / "SHA256SUMS.txt").read_text(encoding="utf-8").splitlines():
+        if line.strip():
+            digest, relative = line.split("  ", 1)
+            rows.append((digest, relative))
+    for expected, relative in rows:
+        path = root / relative
+        if not path.is_file() or sha256_file(path) != expected:
+            raise AssertionError(f"checksum mismatch or missing file: {relative}")
+    print(f"checked SHA-256 entries: {len(rows)}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path("."))
+    args = parser.parse_args()
+    root = args.root.resolve()
+    train = validate_split(root, "training")
+    val = validate_split(root, "validation")
+    if set(train) & set(val):
+        raise AssertionError("training/validation token overlap")
+    validate_hashes(root)
+    print("nuScenes-NRS archive release validation: PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

scripts/validate_release.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""Validate the public nuScenes-NRS release without requiring raw nuScenes data."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from pathlib import Path
+
+import cv2
+
+
+EXPECTED = {"training": 3182, "validation": 805}
+TOKEN_RE = re.compile(r"^[0-9a-f]{32}$")
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def split_tokens(path: Path) -> list[str]:
+    rows = [line.strip() for line in path.read_text(encoding="utf-8").splitlines() if line.strip()]
+    if len(rows) != len(set(rows)):
+        raise AssertionError(f"duplicate token in {path}")
+    bad = [token for token in rows if not TOKEN_RE.fullmatch(token)]
+    if bad:
+        raise AssertionError(f"invalid token in {path}: {bad[0]}")
+    return rows
+
+
+def validate_split(root: Path, split: str) -> list[str]:
+    tokens = split_tokens(root / "splits" / f"{split}.txt")
+    if len(tokens) != EXPECTED[split]:
+        raise AssertionError(f"{split}: expected {EXPECTED[split]} tokens, found {len(tokens)}")
+    files = sorted((root / split / "masks").glob("*.png"))
+    names = sorted(path.stem for path in files)
+    if names != sorted(tokens):
+        raise AssertionError(f"{split}: token list and mask filenames differ")
+    for index, path in enumerate(files, start=1):
+        image = cv2.imread(str(path), cv2.IMREAD_COLOR)
+        if image is None:
+            raise AssertionError(f"cannot read {path}")
+        if image.shape != (900, 1600, 3) or image.dtype.name != "uint8":
+            raise AssertionError(f"bad shape/dtype in {path}: {image.shape}, {image.dtype}")
+        # PNG is read as BGR: road must be pure red and all other channels zero.
+        if (image[:, :, 0] != 0).any() or (image[:, :, 1] != 0).any():
+            raise AssertionError(f"nonzero blue/green channel in {path}")
+        if not ((image[:, :, 2] == 0) | (image[:, :, 2] == 255)).all():
+            raise AssertionError(f"red channel is not binary in {path}")
+        if index % 500 == 0 or index == len(files):
+            print(f"checked {split}: {index}/{len(files)}")
+    return tokens
+
+
+def validate_hashes(root: Path) -> None:
+    checksum_file = root / "SHA256SUMS.txt"
+    rows = []
+    for line in checksum_file.read_text(encoding="utf-8").splitlines():
+        if not line.strip():
+            continue
+        digest, relative = line.split("  ", 1)
+        rows.append((digest, relative))
+    if not rows:
+        raise AssertionError("SHA256SUMS.txt is empty")
+    for expected, relative in rows:
+        path = root / relative
+        if not path.is_file():
+            raise AssertionError(f"checksum target missing: {relative}")
+        actual = sha256_file(path)
+        if actual != expected:
+            raise AssertionError(f"checksum mismatch: {relative}")
+    print(f"checked SHA-256 entries: {len(rows)}")
+
+
+def validate_scene_disjointness(root: Path, metadata_dir: Path | None) -> None:
+    if metadata_dir is None:
+        print("scene disjointness: skipped (no official metadata supplied)")
+        return
+    samples_path = metadata_dir / "sample.json"
+    scenes_path = metadata_dir / "scene.json"
+    samples = {row["token"]: row for row in json.loads(samples_path.read_text(encoding="utf-8"))}
+    scenes = {row["token"]: row for row in json.loads(scenes_path.read_text(encoding="utf-8"))}
+    train = {samples[token]["scene_token"] for token in split_tokens(root / "splits/training.txt")}
+    val = {samples[token]["scene_token"] for token in split_tokens(root / "splits/validation.txt")}
+    if train & val:
+        raise AssertionError("training/validation scene overlap")
+    unknown = (train | val) - scenes.keys()
+    if unknown:
+        raise AssertionError(f"unknown scene tokens: {len(unknown)}")
+    print(f"scene disjointness: PASS ({len(train)} training, {len(val)} validation scenes)")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path("."))
+    parser.add_argument(
+        "--metadata-dir",
+        type=Path,
+        default=None,
+        help="Optional official v1.0-trainval metadata directory for scene checks",
+    )
+    args = parser.parse_args()
+    root = args.root.resolve()
+    train = validate_split(root, "training")
+    val = validate_split(root, "validation")
+    if set(train) & set(val):
+        raise AssertionError("training/validation token overlap")
+    validate_scene_disjointness(root, args.metadata_dir.resolve() if args.metadata_dir else None)
+    validate_hashes(root)
+    print("nuScenes-NRS release validation: PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

scripts/write_checksums.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+"""Write the deterministic SHA-256 manifest for a release directory."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+from pathlib import Path
+
+
+def sha256_file(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--root", type=Path, default=Path("."))
+    args = parser.parse_args()
+    root = args.root.resolve()
+    output = root / "SHA256SUMS.txt"
+    files = sorted(
+        path
+        for path in root.rglob("*")
+        if path.is_file()
+        and path != output
+        and ".git" not in path.relative_to(root).parts
+        and "__pycache__" not in path.relative_to(root).parts
+    )
+    rows = [f"{sha256_file(path)}  {path.relative_to(root).as_posix()}\n" for path in files]
+    output.write_text("".join(rows), encoding="utf-8")
+    print(f"wrote {len(rows)} entries to {output}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+

splits/validation.txt

@@ -0,0 +1,805 @@
+001acc7e76db4fac81aa055050794e17
+00665a89f121424595a27537237d6896
+009c734ba4e0469d9d573c629f0c837f
+00aa056fbee4411f99bbc8b59e1ade81
+00c28af35a394780a88a8c52e579adac
+00c6ec695c1349a4bc07397438ffb802
+00d479f92c074090bfb4169d64464ee1
+00e7308da00843cbb240bedbfd7cf536
+01301515bc0943b68eceb2745dd25a3f
+01d0c525617e4affa07f0b4a57f40873
+020d38a2e24d4963a1cf7dd5b9caf39d
+025b6e74513c432c9122e1bd5d361568
+0268d453775c46bf822cdcc12e071e3a
+02866646308141268ef392d062646f1e
+02af9a881ef04c96b02d3ea7fc188d1d
+030f5875902845ab809c33ddc0851e4b
+032133a8a45143ab958d6db35f91381e
+037f6c6a0b5048e2aee789f121574de8
+03c0580c2cbb4b30b38d1e548f4ff34d
+042f582eb2bb4231910918ba85f390d3
+0430e3a2bf43455a95794229e32dca64
+0481b8a146ba418a9184279f6d10ec7f
+04d7a1384c0c49efbe427eb6990f41b8
+050b2d9c4bb647b7ab4ee94bdb538e1d
+051277513f214a8e885e5791cc001657
+0516e8dff20b4dcea18d42579d84c18e
+0565824603ab431582733dbc9723a8ad
+056becbc0d5a46da8d59eebddedb47bb
+0577d14282684e9ea0ddbce7c858d30e
+065cedab9ba84203a21dce8b21a95153
+07175443e8444b8c8c4802fd004e33c1
+072a217f2f3042bc98ac7cc63afa1a00
+074657f408d64f42a2f81a86ae354eda
+0757a34dd49644e7a24c18902a455e1e
+07822f37eb644d5ba749662d707a3312
+07c29094cb6144aa889c16c52f762d79
+080e1fb7e3d0417795750b94ae91af97
+0825e6c5299d4b89b571168c37a8c778
+082c1b8291e248e585f023eaeeccaf3f
+08322e434f6440868687f25959fc54d1
+087a6c59d83445e898b7b5e3401b962a
+087f8bec119046098d271b336fe03f6b
+08e60c480357494880930e64ccca9914
+08f59ce969f54dba825ae35ed927e248
+0906cd9620604d86a18a71f142312546
+0915646e387b484785ae2b847ffdee2f
+09d89a75ca0741df8471f2f180eef346
+0a3abc33048d46f9bd78151d1df4b004
+0a95f81333cb4aaf86fb63df52504845
+0ad063287d264de3a79ffc4036956ca6
+0afc7ea926c04e389de151cb3576eb94
+0b4e2d1ea9cb43a3adfa99e04c419238
+0b829a1f8f024f1da39208c0f7effb3c
+0b8e1dd9693742b49034a0796dc01a8d
+0c3b121d54d542aeabc04e72d2487559
+0c4c4259127a4de69b4984e31982288c
+0c58499dbc5343fda217a922f0b01add
+0c6b4f84a6004e98b253fb7737fba44f
+0cb4cd11142f4ff5913d9657ebfdb627
+0cfd15003c8d4342824ce89d2892af7e
+0d098c7bbd5045f4898c64ba7d92599d
+0d6668bcb0644bbaaee81c17cc308845
+0d857ba7fe584d9880497c92bd4f4c3c
+0e68a9b31f1a45b499362f406fdd3518
+0e746b6042b14ce3b08dddfa903e2619
+0e837c21890a4515874247ceb3dbf5c3
+0e85a38544ce49da8244d623c36bdd53
+0ee7e7691e3e4bd88d43150073906a4f
+0f6e5e4ebe014ed0982fc29e4fff21a3
+1046d673d57e4c1682bd7b99750f5640
+106019a552b7422c835a0c6581cc365c
+10e1acb531d14c9baff6e0d758016fc9
+10e75c729af74a539a37348d94b8d4f8
+11733e0d03114fa48d139a8f545138ae
+117850b16f73431baa46d97483cc3c66
+11c3568bc3314bb4a52a8c2a5f301667
+125bf46a76ac4b45852d9771e005dc07
+12b84fc5196541db9e57972493299107
+1309b0946c9e465f8540a9630cc50e78
+1349c952687e4dad82a456f938a25e1e
+134ae8a8f5c340f9894a414fc0966af4
+1378783fae574a64921bd144e13b149a
+1397d97da4be42a28b30f053489a22e3
+13dbe757951f43b1923fed3def0ced06
+13f6a070a53740ea9abc5756ad9f08dd
+140489163db54cd6ba017c6affa8dc1f
+15ddb219df5e44ff97b2f56dfe43f175
+15e0ce420ed241a8a5ad10b7f4312267
+16233b066d6946af8f94d8f1ebfd6cfd
+164f783759ee4cacad5ce057e4bc33f8
+16a84d6a33a54313ab21296acc0a423c
+16be33a44cef4fa48ea6e2e4b28a2b11
+16d452cb1c1b4bb090deaed261fa6325
+16d8d4cd2cb34921ad185ceda2a82aa6
+16ec1ba4fdb045b38ccc8dc4016e73df
+170124d2d0c74999bc66fbf207941777
+178263c0453842c3b66e47b6bc5685f6
+18174b773d9449e489f701535c21abd6
+182dcb88dfcf4c2986230bd139805707
+19bef248fa2f4d62b63c92f08fc5fb34
+19cfb9dfc26947fcbde40c066bb7ad8c
+19d58b42f9bf41c7b23a0ba78f8acb67
+1a41ba0751d5497ebd32df7c86950671
+1a7e91a9b7d0405ba4d261c8d6bc6b82
+1ab39fe9bbe14ff198626e388270fd1e
+1ae5e9934f0f43d89923551200a33641
+1b4add4789c64f84b68643d004173d60
+1b4f3647aeed4b3e96a2aec4fb32ef62
+1b7d0a6d69e542c7955bf942a42f6586
+1bbcede176b14832b9dfc7fcc0418856
+1c5c458b8a654bde93548cd32becd7f0
+1c640fed08564c4881e583e0498b496b
+1c969990eb1f4d9297517d6c11d715cd
+1ce3e34a59a647be8805f0f825934062
+1d0e875fb7134d5ab8927ce64fe2feea
+1d4e17443bf04e95b9207cde259843ef
+1d7a57c5ba544eb49a5e174f8459e628
+1d9de3318c3a417981e3fa4ee89bcbc3
+1dacdffab5c240f1b20e05566b940ef6
+1dc0ba023bb84217a1d1fe534a7d4ab1
+1dd4f030ecdc4ac6ad2d61a5e0b9b1e5
+1e0d1b76ea134c7db0592c4510f5e737
+1e2ca68ae0fe4f0a9c8cecc6e45b0469
+1e80c3c5566e45408195ba718b05165a
+1f07801f3c5a4e189705d749522672ed
+1f4b78720c6343aca9f8d6e5458f5657
+1f4f68261696478e9a392d83f576d068
+1f7eddfff1a64c1c8daa5883783aa3f2
+2063ba46c0de4ca5919dec45ed6e1dc2
+206b92bbf13843779e5278f5b26ede31
+20973517b82a45bd93e1b5ae135791ff
+21ad110301c643c2a2419e130a1f07b8
+2224fdf1bf6e48c285cd07adf152aac9
+22371f36ca124fccba946a71ffcbb3d9
+229711ae135144bbb422244c64ced2d9
+229f774ed3094b2bb23c32c435b8499c
+22b2881ee63046a3b5a680fc86f2023a
+236f1ecb6ee7459d918cd011831674d6
+23871c1ab4b643a89c671ebf3d1f0121
+239c9c2687264bc1b64a154322838f70
+24488637f5c2431a98e6b7cfee3bf857
+245c01efd07649918d7fbdf61df94fe7
+2535ed916a3e45ba8d35636de7a3dcb9
+2566ae6a7e6d43419753a78381cf6067
+256c00199ff648dc96cb0205715d9bdc
+25a4a6aa9096458285cba35c950f2717
+2690c36281244c06b709e9f4eeb1317a
+26f72b4fc58f47a0898dbbdc5023575c
+26f99f91a8e14038bd52aee4d00df394
+273c930b3f384bd58b2bbae02fe81d1e
+27749aa3de2545219186c61d4d415e1c
+277816f6b9d04555bb6db18dc67c89ec
+277b967f11ff4429aa74268c95eead1e
+27811e14e7874dc3b5e861e2b526c760
+27ca643c579f4c129c06afe467093ca7
+283ca7ce51bb4f8c8655cdbf7a431744
+285546185179451da3b0907f8bd0503c
+28e802a0a89e4eee987034d7a13f075a
+2914ccfb8ced4734818e651e3c81993b
+2983c897383e4cb2b2df9351e0bbfad0
+29f369497f264f34a1a9419fc0283e38
+2a001771a6024a64ad3224fb91fa1b06
+2a3e8e88e0bd4bea818d4071d365f700
+2a566b259bde46af9d6df6905a60e5d2
+2aeeb7ac5f244406b8017d1e7b795df8
+2bc817494a974a4ead1b3e6b6bdb4b99
+2bd028e4a38749e28f7df4b26a52d660
+2bea4396f5de448c89589a6895f8eae0
+2c08a86ef0ae462f869a5654daf1c948
+2c54067c142b49fa9e0efa818d46f724
+2c77ee386aa0444aaf27140fe6cc8364
+2cce8c92274641ac80acc16f7a98a77f
+2cdea0117b7b44b3a4be45008566234c
+2ce7bbbe90684f82a0c90da4334f83c4
+2d2b9252567e42338a624c975465849c
+2f877311b702477cb14cdc54936858bd
+3018c0295fb7498baf1bed6096f8ae13
+302bac1b032242fd8bc04ec116bca617
+3075963b6e124521bed2c25996a1c941
+308944b922fa4e6e8803231270223362
+313d88c76fd7443180a2ee61d0eb1904
+31e543b3c4544f33822e046577534d49
+31ee9b01ade74b7da5155965772dea34
+339fee0725b8496e98032f44352a14d7
+33ebeee68d1948d0851f465e8568e174
+3403b23df15a4d6bb7a52dd2d0d8f59d
+340c6ba976c94c3fb3961ad9bf6d420b
+344e3d96df1d44dfb8fe0ee4d69b980b
+34e14c18e08943068c1b216977483bb6
+34fb45d038f24e2b9dc68ef2f9955cf6
+350222ca342b46c195ff574af999bd0a
+35d5917af6a04eaaa6a6a56c9ef0d0d1
+35e97896579e4505910a3ca4b0aeb66c
+36aa1c0eeb50457b97911c3bd742a730
+374cc878c3ac443c8e2a901020a1aa8a
+37a6775bf3634ea2b3a4e814c974fa74
+38372de574a0493caac6f052029f52fc
+3873d8fae816458fb86452f03f74f34e
+38c4644a31bf4b7a9dc5493c3511edb6
+38fcfea08bb94165aa2f7873ef4c8318
+39b83a77abd448fe90c290a16a2df2d1
+39b93b7428954d718a43c7da7b5b01f0
+3a08e36b0a7e4751ad28e4966f7f83ee
+3a215909c71748f4b60e3b8b2365339d
+3b12e85035b54df1a00a596e48efb661
+3b33465711eb4ee3a0afce469738dacc
+3b594831ff7f4e27a9889c7b7d0d8e92
+3b594af1b130490989536590345c9dc9
+3d1a12210ffe40939d87303db27f264b
+3d48b21a2df74b3c8bd2124f5b3dbd66
+3d7b4c9671034d2b998ef6b208191745
+3db1f3dc74494b20b683b5a8e685eb36
+3e16485d2ed3436e8fcb71ed66015120
+3e71a0ee309a4b89b37563e1de2c4a1c
+3ecbfde575374f31ad0f2e0c4547cd60
+3f2ddc9476eb475b8c46f777f508cedb
+3f597ce7f45747a79082e173f4a2b78d
+3fad9ea6895244ceaf1b0306e02eadda
+3ff58ee0fc4748d9895300f02114aa56
+4020f66a67a24f6c9be67d5deae5dc31
+40a75e2e0dc24387bfdb5bffc306eb70
+40c56835c7e94bf290e12aa0b1ea92c2
+413f259bf2284c4682d5fd242f0b6e1a
+41550a1f0b0548e5823b14d95e807c7d
+4167fea025514f9fb2f5643f87862cb4
+418341f41530495dbc5c78e50ac45346
+421d83b3124146469b25b185fc90d74f
+42232640b63d4aedaa3311430a4291e0
+4275833953094de2bdaa78ccf78e51a1
+42c4dd1fcf5147c5b98064455d29141e
+433841506c744582b598c5190a141542
+4358530a0f1e45618515d284d0920a1c
+4363a87202c944aea191d5031bfb1953
+43adecbafa4a49efb4a7614981b71f7b
+445e9dd3fc1348b6b09545b5d88616e9
+44a52213522640f8ae90ea1c4e21e97b
+44bb391f20ef4dd8830f1812ac2c70bd
+45768e4f5b3e4ccca29ce2f3919289d3
+45a0e35595484bc0a6644baf461c99e7
+45e03230485941c89c8835316334e76f
+460528e658d549b68540b4ca9528973b
+46451e11f73942f788ed60ad188e9f29
+46d180be54d3499189bd658c2469fe52
+474423dd45954adbbbf696287ae96225
+47817d5850f94c5aa7ab43f229912025
+47cf66759a934360b07c17911a3c755a
+4858c06688ed47bab82a71184bc0f8dd
+489f5a5bda9d4cd4a9f7f164161c06ca
+4998876515cc4ae8b7c7210433a0b2d4
+49dfd2f2fef447cc9b8dec3e17c1c919
+4a6ea70dea914f2d9cf939dee3f47b4d
+4af3697280874ce9b05ec5b2c442a6e6
+4aff4a8180c4498da1c3292518542c41
+4b9b2c02a4cc49158e3ad9425889daf2
+4bb8746bba0e4762974f5b1cac8b8b2c
+4bc92d753d1a4f9f95ae42f8b0aa6722
+4bf1d36d32d94f04bd09f67d5cd502e8
+4c1de865efc14836953a3cadeb6ea489
+4cd1b64d8de14d06b399e17d15fc2c66
+4cf912b4689c47b38d8d5c226c4b0474
+4d0cfea5b50f43189e9a056cd6a3128d
+4d0fe28f87724aeebaf3892fb366bdeb
+4d4e4c0fd8ec49bdb12788e0a9ecbce3
+4d9aa5c2b7354fdf8e7e47a4bcfff87c
+4ddfec3c0eaa48eebec29444c5ab7e83
+4e169e93acb346d59de1af7f2b4882e1
+4e1d1031fe9f45f981a2f598365fc645
+4e237101f6284da7a84ac9fbe3efa23f
+4e3596e697f049e4aa82953916f48ae0
+4f4d04f823944f4e8bf58bfd9a97088a
+4f5d5716e3c84ff4b1712fe3ca2cddef
+4f6de7952def4f19bc83486b12ab29aa
+4fab01b54ffb4cb292f36a9e37d6042e
+5074ad6e7bbb484091f96d6d5b0b8401
+507efd4d15d54320b3cd6723099bd92a
+509ea128114b40e7b72ecfa0bdc7b490
+5121b3dda80e47b28ffada52f4dc5c95
+522e23c73c58464fb36b78099fbcd116
+52382fba2b69421e91b59ad661d4428c
+52b77f7493534fbdbf9d07728d466421
+53e4ac3bfdfe4de8a10168cb833d1772
+54a0a741163847349e20097f6c63a7e9
+54af3641e4e544a9b36c437f4bff066e
+553535fc45154ecb8103eb6d0429c8d6
+5569a7a3c01e4501b8f3e8f4371def0f
+55addb9cc46645ac92ada6bdcd0b991f
+55fc7ab524af4cbe858e6307b7e6de42
+562afd8761d04b94a1bc4ce1ce15ea82
+56da354d5afa49e68f2c92e49cdb3f67
+573143da5e3e4b2f915115d5fe10cb45
+580aab6fbbfe401797676c4815b35116
+582b905936e44033918b65103a931145
+584d3bbfa37e4ca4ab411c4c3c945c08
+58ef4e1860754b0aaf7645dd9e76de9f
+5a038263bc9a402da315e1fe4e173c7b
+5a3d768f976645ab9561c27c3639d258
+5a89d8fc38014772b9da2c3fd34b8392
+5abb17189643497f8600a187fb20aa55
+5c0bfcbd6a704036afbf21eda15e5486
+5c1d145a31544211aad6b7710a6d0e87
+5c80c08723914501ae10dd59c27c1300
+5d40ca5d881842c2857d9e9bc8068a07
+5d6064d6da1144d0bf844fb1c3d69507
+5d87df9e71524d46a9457acfb230eaac
+5df9c8b7f24e488ea6a922ae74c9c251
+5e4ad06ddfa5444a96a68b698596b944
+5e9bfb1da7cf4469bc29c507e2a885b3
+5ebba3c2a42d46969f8f81897fdabb25
+5f32871d1abc446e9bebabd5c5b1d6f4
+5fc1727d3d9c4e419b969c5fa28c4bd9
+5fc2575690734ec1aa2b45ceb2e12c73
+5fcf31022eb54412a4b954dd0de89767
+609dd6c32a5e43b18737b35aec6b1034
+60bce8b1dbbf4e5b8629b4e59924d3ef
+61147c7e1fd6484cbfb2d2bbce276b73
+614c6962e44240b1b0ebb3eb351fe0eb
+61cfc5554a724824b0d34bddc147d890
+61f949883ba7405d99529a8b9fb9cb0b
+61fd401b91db4c9aaea63945a8b87df1
+626f6ba092844742ac3447b69eb0fe72
+629323e575754fe2815ed5926581565e
+62a9acf2b9ff42c1aebfd10627ef72d8
+634807bc68f94beeb869b9e1c01c6673
+6372712792144ebe9443900597ffbaef
+64493dc3ca644343ace1375e9d34a5bb
+648fe1aeca944fb793b334cb6ee01854
+64ba8182ed7f4690aecb99aeb69b178a
+64bc2a67882a43b7ab4d6349aa8c9f04
+64d3946ee0bf4efdbae21e387d9190ff
+64da0eefc1404f948ef30a6abb88f0e6
+64e66d626d5d42eabcfc1e9b9f2a6e91
+6516cdb76889454c9259e77a68ad38cb
+65db946ee2b24f77b98c8c5a9702f7bc
+65ddadbe30ea4256b6f397b442382d10
+664518a7a7754fabb97c0c4c3d1923a7
+66e35a873b34445793d0efafc9f7e591
+673a97d809524cf795ee4e641bcdd0b1
+67489f6898d24b658f563bbcccc56406
+67bf079a21324b93bc4ed2be26f3e26a
+67d2540d4e104e2fb8a54e7b5a78dc12
+68115096691c4a36ac9fa3ea44dfdd7b
+68ed35936729495799a9ad0ad78b2e10
+691d7f2148fb45498b7160edc98e955d
+697cbf95c5b74e17a6d03b31ba757b44
+69fbac1eaf274e30a8e4f6f4f5bfaef7
+6a19fce898cf4f61b07d7b34db4a45bf
+6a24bf71cc954e0394de813fa846c422
+6a2504e57f5643d49688d5c5c58a1122
+6a5ffff19da3462591f6185983d41138
+6a8a5ad30e114e9e9781c236efc34987
+6aaac99d4a794b54b5f67836a3b25c42
+6bc967a989cf44aebb4d71515221f87d
+6bf25bc4c0ae47068245b05918173ac5
+6bf306fe03a142ed920576d2c9142280
+6c1f430a6a214cbb915401f2d518b5da
+6cb024831cce4b6e8acf85afb7cece6e
+6ce51a9ca9044b0596d44eea36237b58
+6d4b0e4cc7a147c4a0f7e396abd3a0a6
+6d7574d3ac054776b67fdc05a5ddb38d
+6dc25b37f8674e2389690f696392f586
+6ddbe3473f9a4eb1a1e9c5861e19c8f7
+6e47d58dc74a4407a00970ade1b895d1
+6e5e6593b57c43d69d2c237121f41617
+6edb9cb7eb2f4b24956f058dabae8054
+6f3f54eb2ce54888a6c6a8cdca6f2e59
+6f641914dc1a438f9cd22266f049f7fd
+7000bca0e2bd4134b0ed1d6c98d79d3e
+707adf9db2084990973d30ee2f2a04db
+709703b9c11b4adfbf810eb176333ec1
+70f0d89bdf8d4598904f87e9af1f331f
+7147d8d1b51b428fb408f34799325111
+7196e0f5dda2478bbe1ad06eb0e348a4
+71bd05582c274214b7f52d3720e28c3f
+71d53b1b11a7478793e06711896f6810
+721ef3e25efd4e41b7e218cbf3be59fe
+72a02602d97a4e519a18517a989f1c8e
+737062db4f11494aa489045e5b1ea3ad
+73751e603335483eb8d13618d03067ec
+73d0113754fe4c07be8cd9d40d330974
+73f9b30498834df386586c0d3b1f1c72
+74f37d96acd54917992d76cafc3e9944
+75691818ed324d48a20415d0eeb297c2
+75ba8f88124b4daaae05e5e8235ccc34
+7681531dde8f4132b949fb1e2e738fb5
+774680e9468644d7b9f00fb70b784b7b
+77b6b67d28e0452fa935055d4afccdd2
+77fc24547ab34182a945eecb825b6576
+79159f7a87a0472f970e628e1d04b1a4
+79fc824ab8414df09d6f28e06f97e6a6
+7a05436558f5464a858492f762c8419c
+7a2319bdf0b64b498d3026d1c4aa0fa2
+7a60f1da970e43c0b1e915b0d62b8114
+7c299d32fd95451b83e23c6e63a3c548
+7c31fe05e54b4fbebc0b16678fc14b21
+7c619ca63a1e4b788352f861c8d3bcd3
+7cec5e7b20044f5da63c805c8e1adc82
+7d82aa0c679141d1a71733b85fdcd3ed
+7e1b153b446946278fe18853f968eeb6
+7e85de15de2544ff8c2d975acbfc1e5d
+7f51af0bce4b48e7bdb430dc4fdfbdc6
+7ff35bd62c41453c983870a774052345
+80e23e78839d46e795795c4c1a548287
+815da77946a94368a846c6ccd760780a
+8178cfbc864e4cb0b6e35746b32bed9f
+819649b9d40c4a3eb63aa02ea86aa15a
+81b74ed83de54fcebc92c6f8e163c054
+81c355bb940b4809a720b0c1c6ba10fe
+81fc8037246943a592c04c67448fe998
+8205f9e936c6463abbfd485ec5a59385
+825e36c324354f2caf0462dc5fbaa7e6
+82cec7b2aa3246328991165f9eec6dcd
+8336b62c3f6f4bb988c3865cc5df4446
+835b3413b9674cbbb52a3f7649012668
+83c9b9c6781a4808a88c971fcfefc46b
+83fc2ab79a3a400b8aecdd9c81f13790
+840ebbbb8a4446fa9a2421b5c89bb7b6
+84415639b5b448c8b6bfe0744e7dda3d
+84b1faa4aebc4b2f892d7b7a9e775bc2
+851a472129cb4a58bc9a02e243e5c3b2
+857fae3be36443429142346546d7e935
+86786fac1a484d2eb892458add7e4e93
+867b8f137c5048c398bd80a74a2685ea
+86858a1282a44814a52f9daa532cd484
+86a38888decf472b8cd3681d82ec1afa
+8764eda886ba494ea5a1fd1442615d43
+87e4a7140f9247f6b6d6aada9228d4d1
+883405b988db44e0aaa275b45ac716f7
+89354b3eb74b4da78ebc4186d68bb0ec
+8a612f44856c4206b69811d7664e9d9b
+8ac6c53be5e4438aacc163a391e0d963
+8aebf178791146e1ac11a816c5600d48
+8c91fc590a274ec3b67635e7b09c3072
+8cc06390249d4895b5b9b860f0952f24
+8d211c7a254145a5a028b5f3185b12af
+8d684cf8abce4d18a9f0ab8fedd645d7
+8d7dcd1533704f5882a5afcb65509ed5
+8d997cc8ba4340729119cd9989429933
+8da3ec3d729f4b9197a676fe00499fe5
+8dbd093105d04d67babf8bed1b3e2d81
+8de3505db94e4a06b8dfac5fd3d69b03
+8e5512a630dc44c08d3e3f692b34f808
+8e8ea5034d494affac52423548031d1a
+8f4744720f3d43a1a28c0751cc3182ac
+8f535885fc8342368cd9b4c342ab24fd
+8fc8248d37654d33b6b1c747847dbbba
+900d2fa2780448eda28168e64411fedc
+90bc34df30b2428aa1438cd59825b5f8
+91424f52454642eba89bc27284cabf02
+914e2758331d42ad97ede94140784a0c
+917590ac1b874a7eaedfbe691886f7f7
+92026e052bf540dea11a32a7d1cd8197
+9216b3b3223041a38d5f9d6ae243b806
+92d07d4bf543498d92ad3f223b8a1d89
+930bb914469c4efa9e9178b42c57b897
+933f8af57a1a41938e0f60530401acdd
+93581f7f7f414972ab569e80cd924e00
+9368e168276940c49dc882a8323a5bf4
+93f4f8ac1145418cadcf14dfd2a9cf78
+94e0f187cd93419082a95d45eaf4001a
+95c0a92d52584756832ec795d346e296
+9600d2233c784ed7ae90733720688f79
+967a3cd451cc4ce3b12f948060ae8261
+9734fb80334b4a9cbbbd60bad043ee5c
+975753352ae744a4a87053122f9d15a7
+978393f26358477eb27ac5195c20a9a6
+981807149fd145bcba93dbbe2db00ff6
+98f8b165f576482a82d0ced97ae8b866
+98fa81992fb04e799c329eca220e7164
+99cf50171a534cfd9c0318b6303a18d4
+99f903d3f74a4f76a05a4f1e10e49329
+9a179b2ac4e9445abb2c4470d72d89e5
+9af8c6dbe0fe4e70bb2097242737f0c6
+9afc778cc4734c9ba3a12303251d64b7
+9b75adec6dbc44bf937e7f329ad50205
+9bb62f29df1b442d829098eb1193b428
+9bd27a83e6ee47f9aa372bbe8a8573c8
+9c0188bef4aa4f278d50491041553af3
+9c30d85cf4c64d4bbe6ee04d7606a3d8
+9c5c65d8353c4b94b6d7231d0de29284
+9c7c7d5d109c40fcaecd3c422d37b4f6
+9c93690fc9e24ebc90906ed922159d75
+9cc9718713c14974b5e3094e1c4eae1c
+9dd921e3d49942c7adfb611d9a75f8f1
+9ddd760c701345e6aa9a3fb07ba5c297
+9ee59e733dcb4d4b99988c89592f5929
+9f3c1ed777844a748f6a2a4a532d047b
+9f703846f357490aaf8f0fba9e7815b3
+9fa3739836fb43c59a5354759c47fb0a
+a007bb258ef64368935f2134b21bc849
+a01a845d7ed2407fb77fc0f60fc74f19
+a028144375904de79f21f2bd9d10ecf7
+a066eb48903241f890dd842cbb7d1620
+a0c85ae7a1b84a2f86a021f91082ad76
+a0d4c1414db14a0782a7915ebb5785dc
+a1077ca56ae74b0f8bf4d8ba06802472
+a1b4f3ebd2d8441cba221df2441301e2
+a28ba5249a42475b94932d8fa43baf8f
+a28cb3edd8684baa925d5b3dd4454bc4
+a2b4eb85441343dcb30a19c5e60e0b19
+a3c460b4287b4585aa947c41cd022edb
+a40c02648c494fa6b4ad1f8afe39053e
+a43568a562a043f38af0ec0b71520af7
+a480496a5988410fbe3d8ed6c84da996
+a53573b8da254128a3642c1e232a27ec
+a5367adc397b49e3b49dd8e9c37c4596
+a5c0ec90615e42818962e4e002de0cef
+a5c90f849579422ab03f94e0cee03871
+a73303e8adda4632b977ad35ea66fea6
+a7649ab0806c4d91a816f90bf838d6b1
+a7a2c378191b4c4c9abdac947d163e5f
+a804d28db9854d89a01764edacfbf19a
+a80878527ac94625bcf4743fef8206ba
+a84f43c4ef52461d940a6c7d0768b86f
+a86ad4a35e4b4695b1394fc94aaa2967
+a8a6bf5c96d147fcbf49633e0cce7fe7
+aa11fb7855944626a48c58c058899bf2
+aa12f4c45c024f2ca6941f97253232c4
+aad7fcfee87f427f9a2e6baca0a7f656
+ab022d22920347678b6fab7093af8edc
+ab46e245575547ed8fb80530113ad949
+abf2d81e20374408944c8ed68fb76220
+abf3d91d3c28407e80e3334fe89c03cb
+ac2d7d96aba34780830b54a184208302
+ac5909f518af4d008a1c574075454d56
+ac8dc6c5efcc4f3498f4816ecc8af659
+ace4b20b94cf47d0b68addac79fe68de
+acf9fcbeb1e346b98640f694f15460e8
+adb0ca825bbd4386b34be1bddadc5df7
+adeb76288a0345a899f08e1ed70c48a1
+adf3d8b9f7a1450ab670acd10f0b4a2d
+ae110514a90b429187cb3405ce97e635
+ae7f3993b5fb4650ad452cb7757f2c07
+aeaa12755c71497d9f542c238746b3c5
+aed0c4270ed24b40ab1611a071cbaf75
+aedd72e9640d4777a4c763ea73817119
+af005e95927245169c5910870c0d7f2b
+af1dbd3671924284af4ef4f6caf1ad4b
+b085cc54b9c6437db176033620d00529
+b0f78e91c5c64e13b5fb42519832ef04
+b1390401cb684e4e8f8d903d1a4e3e68
+b19e53a336bb41b491b7ce09a2ac9ddf
+b1a4ac5193024c4d90b0b5b55bc127fb
+b20ea8bd7a5041388e81e51091118f34
+b22520071138481794aa8c4947166a4d
+b2af46f0857043b0896fc842f20cd1da
+b2e653258e49404bbdf201aa821326fd
+b314b38e1459477ca91ed6913e0b4431
+b3b64c9385d94d808c56c4d4242ed56a
+b3d5371734ac4c8baa0703020f66cd90
+b3e01aa169d04c9f894907c36a594654
+b3eeb253d2e444309fc0937cc0ca367d
+b449eef85550419c8e09ff89830d1dd9
+b47a4be6a87245969b9f49ec1215a983
+b4c279e61abf49bd871ff2ec4b13e115
+b5851b7cbe254a01915c9c321622ee61
+b61678de2b4844119bfbf99d74c2b8d1
+b6ab3e79582b4a49b3caed9a4be892f9
+b6caf1f9962f4495872cc5c815b94fc3
+b6da7f3a8fef4216bf0def6f69363ecc
+b6fd2d6e2620433d92ea475bbf1d91bb
+b728e1ed7f8649e7b39f840bc3a1031b
+b7a696b7e7c94c9696b23d3c4bfd65a4
+b7cfc4d1da7648f2bd57c6e583bd10df
+b7e3d9d0d0ef44a9a3bed7f1c0d9cab6
+b830d6d66b934b949778645cdafdb956
+b832171fe69a47d9b96083ab0f531a1c
+b87fa2e95b1d4a83ba7b49116f15f0fe
+b88cb3fec5864a7ba33a88d790838b20
+b902d29df24c4efda414a9a88ed57031
+b905f597f32648e5beeba69ef3e5a0c6
+b9254548087a4ba482bf4645a7dffa3d
+b97ab2821fab4550b85fbf345b90b7a3
+b988f44fe5794d419f450352f70cebcf
+b993550e60054741983f8052ba97b0b0
+b9d0fc3883b94a8da761b011392decbb
+ba943d6b836a44fdad968d0a0fe43897
+bba3a54fbc8144c1b0ef934d0a2d5854
+bbb8ac0234ed4febbe17de0a30e418b3
+bbc4b41142d1423484cdc0b7ef18484e
+bbe7c0e4ddbf4a22b88d9eb1e1d18707
+bc1859cd462540869870d7105d977cf6
+bc4a791980fc4ee0bc6e9f4da69acb7c
+bcc5fcfc5a06497e9045f32786ca3f4e
+bd3c3463c03f4e43aa1d3d4d58d06c3d
+bd451ad70ab2497686008bed765d8805
+bdbcf562968544a49f88e477614a7f93
+be16ceec2a864f50843087bc90cbb79d
+be30fde2e91247049ed17afd09cbf912
+be5ea56c21c14be2a43193cf50c520e0
+be75cf94ec3841cca384e1c9a2499a00
+bef46195fa2c403e807f2f44be118dde
+bf70c75762b0498b89f8f5add90726fa
+c0157485f0d5408b8419a8f160afc901
+c08393de25794fdc8df3920705e0690e
+c09943fe824c43ffb53b66afc7e8f110
+c0a1b175c6424dbb84d093c646b04d72
+c10d8ebad6f741d497583ca83a98c53b
+c114fcb56775465eb4d89a3d760c1aff
+c14d2751412248568d8822a852615942
+c18d3bcc9297454ba52112c079cb756e
+c196589195494b19942daa73e25add9a
+c1a1f32e00494e1cb589f02e0561bea9
+c1a38f44070c4bcebca2e21dd4864cef
+c1c5deb545fd4bf9b5ee8da94a783245
+c202ead75d2c4a918c58c9931f5b2cb7
+c208b10f4f8b4e80983b0b369e0da046
+c27993a5abde458695701df7adc6fa9d
+c36e8482feb041de9f081e76396cf4fe
+c3a0c23e73774e34b6f2146130e04d6f
+c3d1bdbb037642e78ecbe1cb99a4f283
+c3fe336c6d9d44d98d9feba35de9cd9e
+c4048cf79e5c4b88a5845dfc98b3b1e9
+c4203acc7a704f61a0a77235c48bb05b
+c43fbd41e79249fd80f1815d241cdf21
+c453481ebcec458db5a180a749257526
+c471213976cf4f4fb376e05917bd5391
+c494dd260b804b13be8ba71b2f93362f
+c55e72e2f2184d12a8928a8be07b28d7
+c5832e65bd1e44f5b7601f788ecf6bb6
+c631b61375a642b6b110f5bd5543ef7a
+c690e424602a4de5afdb2f5194b7fc59
+c6a20a439c0849818c384f3a3c8db7b7
+c6ac7eddf31b468db08d9b8b44686e1a
+c6cc38d1f6ef40b5a30a73374b134bf4
+c74dd74a661e4feb81ef42194324fd1a
+c7975b812f8046ff83953e4ed7bb88c7
+c798517864de45cb8884027b4905758a
+c7e060c12940433bbe2d57be9b6eaf7b
+c845c88b8f2744ac95bea1eb23568097
+c8ae3fcd7e9c48418c7a3b3c5df524cd
+c9e812f2705b4b198f4675dfaa33812d
+ca306db1012f493c99165c73938b37a7
+ca31d398f8f444b88068a92cbac97b0d
+ca88ff32e59b43d5952b5aa0dbd44808
+ccb759e574d247b8ab95199f98552821
+ccc1239373064283aed9c4e7c953862e
+cd4bddd33df244b9b678ae08f3fe710a
+cd5e84537443411fa68cf394c5c80985
+cda1e9b375ab4e7f87495cecb7b7d654
+cdc5d6c40a734dc19c923c4cc6944494
+ce60a5da05064f9e97325c16c51e9f06
+cf289b533aa648eebd634d60bf541935
+cf939373048e4c3b875a6fe5c6b0cda3
+d02bdb7645874fe7a986dfb4159bc84d
+d037991d81494af3830fcf06ea25f28c
+d0762c5e6da44e19aff21a537c99a08a
+d07b019548c74f2491647edabc1a5da3
+d10f852db20e451c87d35b104df09b18
+d1136fce62f14400a069613e274f46f7
+d15cb77b647845d4b6b17b55358f3780
+d1946dfac66548c594900374a8b8da7f
+d236c538c3fc4bdebf206e5d40bcd0ae
+d2510aa8fd564d8c94a83f97a1cf833b
+d297511c1dec40c7ab8f44e54e2f6454
+d297927bf813452cb1f8dd9f83b64f7b
+d2b426460bc241b7bb6921670fcbc425
+d2cf52e741c24378a8b67efaa5c5fb98
+d343077a540647948f11425da34fed5f
+d45cdb52b54c4ca7ab41dbea7c11994b
+d47623a57d094abc9e63f44508299c03
+d4b3cf822022481a86e923f9a8d80642
+d4eab108bd7a44a3a2f741f288e4f8ba
+d4f2d7ebe36943acbd606032ecebbf9b
+d501737a45d146f8af94511adaf27761
+d5129f60381d43219ce73a53dc32aab5
+d572fa26969a460fa4781c27cb57d8b5
+d61ef2ae3bd54793b8beec55061940f0
+d6d4aaf8435d48bf92ccc5db780eb952
+d6ff811ac59b4879982ca9cc6a7724ae
+d7750af01a6e401fa7cae725ae990b6c
+d796fe3fee2a41dca994637677c024ad
+d7cb9aa06de1442d8e2a22d562045cb4
+d80ee373feda4f449b76a06c2afece6d
+d847827ccaec4c5d8d79df4507980d65
+d86f77974e534d1b8c4910251c7b09c7
+d87928de430d46ceac32c80bcb6c2ab8
+d87f850baf014487ba8286d5a4c858f8
+d888055e2d3143279b680a88399b84dc
+d8c48a8010644b9fbc5146bcc5f3423e
+d9acd321e2764ad2ac71cd46955d93cf
+da19913456e84253b7c7a9df8f048f4b
+da1f65a1bf0243599770293ef3eb66f6
+da24031547b04c998ade039ace191ad1
+da5a6eadf7b74abb944df9ae25bf7f5b
+daae21dc94b74898a7362922e8792415
+db276f2010264019b76b7f3cf383343f
+db32662d82ea4a7ca12b3af5934c87af
+db886d257bda4130a355ac13cb3c35ae
+db9921688a634e7e9fc963b9363aa3bb
+dbaed41d17e14b938b775d192a3aaadc
+dc4c80e8a1534ff8a3eb80307341161c
+dc53cf076d114df7bb59c2a0b3bc3154
+dc8f0646f77f4dbead65f5ccfacafa19
+dcd5692dcbfa46d6818875e73d221a4b
+dea589f5596d40dbb2d6f0c817427b34
+def0724c22c14ae2afb3ee752771b84d
+df661459175848dfa13fd474a59c5e68
+e0228577f3584b0ea6f7415baad201f3
+e11197eea9584485b2e1c85bcb952b5f
+e169b19a2829404aa91dcda37e657354
+e254c1f1948044738856fc1f10345fa1
+e25bc59ec54142d9a3436bbf2bea82e1
+e2ecc7dfd4b245c4bb06a24f74d3bf58
+e31aea95240a48f8bfc9353b745384e5
+e32da26413474192bca8dbec5ee55600
+e36c6286d4c04d22934270ebf66fca7e
+e386ce38d87e4e699b13f618af167829
+e399ca0b966248b8b5b3c3131ed80218
+e4299084285843db9970521e8b7212a0
+e473399dc6e648298b6caaef21e9bedc
+e4d73cf6fe45495fa87eed49c3a0d8ce
+e4dd73d0476b4f03881d355cba04654b
+e55c80999e824179a1e973d3a3f543da
+e5754b34b2064f6db39f5d5314f4dac5
+e57fd5ceb5b44be6a8dfc1c1f6b60606
+e5b0dfece8cf49fd860a9a28e3867874
+e5d9750fb461470aa4d6574ba90f69ff
+e5ec2485e3c84ee3b4cd0e5681c7776c
+e6467af1dad8492f8e217a1052271590
+e681bd8589f04cff9593224a4ab35b8e
+e69287eb831a4f9cbe0dd27c0b393514
+e6b0b282aa174a978272dc2d0a89d560
+e6d4036eb8334c2ca5adfe011a767c7c
+e6e5845a2d2848138d35785b3385edae
+e7076f06bea44e239d2ffb8b39509818
+e70facf946444ef1be26db121c57c1bc
+e789e3e84dd74a63901e381a483cf340
+e7cc339e60a24f34a3abc3a32c7dd695
+e8203d67db104c499a0335c38ed0afeb
+e82fab5fc9cb4f11977c5d3e5f8b98d0
+e85dca76da664ef7a1d372e42f44244f
+e8b390ab7a1e4fd9a400561408588cd6
+e91a8780af024d8dae3043ca02b1229a
+e93990fa42474da7aa141524f5f0a7ba
+e9a71dc2441f409aaae0c6c3f333dda8
+e9c7ce55d7704391b63e98ebf89d67b9
+e9cabff1d3904919aa1e006451576764
+ea1ac89bfe814459b84cd151bb75a83b
+ea55b57959724936a4075d12ac714fd3
+ea85483fbaf1483d970878f3556cd8b6
+eaca7c91decb4f3d8c87a7010af3beaa
+eaf17ba77e654c48b53b50f0bcb17d79
+ebcfee01288640f2ad8702c292a17c2c
+ebea992454bc4e418a2b347d24fd2376
+ec0111a6f7de4fc3bd59eaa20a0f2c79
+ec1379a5976f48ea87f9206bc86ca753
+ece32f50fcda43e9948bc9b104dd0f8b
+ed6d74a033d14d5bbd61e4b3cac44fbc
+edbb01fe0c424c64972abf99861ec8a1
+ee2e198aeecf45948045cc1c2ef61ac2
+eeba6acc450643188ba1e613a9200668
+ef245cdcc79c448f8a9488fe9c06ccb9
+ef8d863c3b954ec8b21957a8f29c788d
+eff61ec3657c4d1c9327e3fe6ca639d3
+f0a718e817db4fbf935cf8be161f3382
+f104429d63c7448a813d00e0b1032130
+f1b932b0d0804f02bea440d72047febd
+f20453ea64e1431a9c9c64d4fe8f1cfc
+f2a6d0e38153467ba0d02706024e258d
+f300318644c742fca114ca69bd1f4200
+f301c19f5c5f48429f724621b3f25323
+f49130ea0b28440a888f605e61c19e94
+f4d9b6154b5c4a729ed1884c12695856
+f56c2cd561174a9c981cdd573f6c90bb
+f57645069f9a481f8a388c49ddf9f78f
+f5c84e4a736b45228922d56ce183d334
+f5eefd9b8f024c299253db54fb0677f4
+f5f955d2d7594fb4b18ef615b421c98e
+f65ffdc408fb4a0c8ef0d1614b47dce8
+f6892de50d924e9398769ec60d024283
+f6b0a224aeb14190ab0a535dd2eaf47d
+f6e2437d2e7d4b66afc6278019250c66
+f71601fd11b54eb3a5a8a70b55132b9c
+f7774606bec7410089d84d80f97b6bf6
+f77ef1c17cbf432587d705c88ce76b3b
+f7b7254a6cf948f084581bb098099b0a
+f7c3ee85cd0c44ec83cd3332373f1c64
+f7f1a5bb933049b8adfb93cef00a65a2
+f803286c6f664f8a95d4bf0d383ac9c9
+f82d2f4cc2cb45babb7319f21d1f4b62
+f83089bbb9a7474ab4496a32f9fc600d
+f87542a27d26414a9b39670d2794c195
+f8e43e845ae34028b6358cef2c0b9191
+f90292e4cdf647e1a8842baabdaafcec
+f91afaaf3fea412ebb9d82c8a8349991
+f966614ccaf44d99baa7f1d8f1b7d4b3
+fa6cb2cc72b545ad80972d23d0022791
+fb3d12fd61c646d991866a060179be46
+fb537f9ce318450dbcc91386b71d9d4c
+fb61d590dd1143ccb12ea56fbe9d9d07
+fc8ed14d78fa4879898315f5dee21d38
+fc8f30e5ca4c489d9b780728ae5a13a4
+fc9cf867ac9440779d4b5f3a9d98e878
+fcf937eb6ed740ae87b28d7d5b362930
+fd01fd487ac34d99bd030c6dd55b200d
+fd0a47d4eb624488a444e8c3ad09a724
+fd8a906f9eaf4c969caedfa56d7b0be1
+fd8d991b9622475ca60c1bd48faa1014
+fe40762a54e1414da73de751877ad576
+fe4fb18c37f940a9995998f768417512
+ff1439b86fbb45458842042b93058fdd
+ffaf19c70dab44ff825e76f9d1233e47
+ffcf53e9293241179f1e2fee6b852d05
+ffe1639f24874474b36cdff5c7b8a4f7
+fff7244095b441d6a053da2951cf2b3b

training/masks.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e24ceef6297e9542efa4257b643a409080acec21dc18e315b5d635f35287bfd6
+size 10257846

validation/masks.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c060135f2ef8f20359dc8f502071c8051e340cc3a9f136664e64f1e43f90255b
+size 2498652