| |
| |
| |
| |
| @@ -1,345 +1,118 @@ |
| -# Hugging Face datasets |
| +# Hugging Face reproduction data |
| |
| -This guide covers prepared dataset snapshots. |
| -For trained weights, see [Hugging Face model checkpoints](HF_MODEL_CHECKPOINTS.md). |
| -For source downloads and rendering, see the [dataset guide](datasets/README.md). |
| - |
| -The public [PartProbe3D preprocessed dataset](https://huggingface.co/datasets/cubec/PartProbe3D-preprocessed) |
| -publishes saved observations, calibration, target grids, completion markers, and split policies. |
| -The full extent bundles also contain posed geometry. |
| -The FoundationPose bundle contains an export for training without meshes. |
| -The dataset card lists archive availability and links RGB/mask/GLB previews. |
| -The Hugging Face viewer exposes the per-view metadata indices. |
| - |
| -| Dataset | Training views | Test views | Local root after restoration | |
| -| --- | ---: | ---: | --- | |
| -| 3D-FRONT | 39,930 | 10,066 | `datasets/3dfront/extent/point_cloud` | |
| -| YCB-V | 0 | 900 | `datasets/ycbv/extent/point_cloud` | |
| -| SAGE-10k | 17,456 | 1,952 | `datasets/sage/extent/point_cloud` | |
| -| FoundationPose | 42,256 | 4,692 | `datasets/foundationpose/extent/point_cloud` | |
| - |
| -YCB-V is evaluation only. SAGE's complete 64³ point-cloud extent contains 19,408 |
| -views across 9,931 rooms. |
| -Of the 20,000 calibrated captures, 592 did not have enough visible prompts for training targets. Its layout-level SHA-256 split keeps |
| -all rooms/views of a layout together, with no validation split. The Hub card |
| -records archive upload progress separately from source preparation completion. |
| -FoundationPose retains 46,948 accepted captures from a budget of 50,000. |
| -Target preparation excluded 3,052 captures and reported zero processing errors. |
| -All 1,000 sampled views passed validation. This run skipped full validation by user request. |
| -Diagnostic subsets, raw archives, model weights, and model-specific feature caches are not in this upload. |
| - |
| -Install the project's preprocessing dependencies, including `huggingface-hub` and `requests`. |
| -From the repository root on another server, download and restore with: |
| - |
| -```bash |
| -python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset 3dfront |
| -python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset ycbv |
| -python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset sage --cleanup |
| -``` |
| +The public [dataset repository](https://huggingface.co/datasets/cubec/PartProbe3D-preprocessed) separates training data, optional components, and deprecated uploads. |
| +The default download supports SS, generative SLAT segmentation, and 32³ SLAT shape training. |
| +Model weights remain separate artifacts. |
| +See [model checkpoints](HF_MODEL_CHECKPOINTS.md) and [pretrained assets](ASSETS.md). |
| |
| -Use `--revision <Hub commit>` to pin a snapshot. Downloads resume after an interruption. |
| -The downloader checks each archive against its SHA-256 checksum. |
| -Restoration refuses to replace different existing data. |
| -Each dataset transfers one file at a time through sequential HTTP requests. |
| -Interrupted transfers retain their partial bytes. Different dataset commands can run concurrently. |
| -The downloader records progress in `datasets/<dataset>/archives/huggingface/<bundle-root>/<dataset>/download-status.json`. |
| -The downloader caches archives in `datasets/<dataset>/archives/huggingface/`. |
| -Allow space for both archives and extracted files. Source manifests retain |
| -historical absolute paths as provenance, but the loaders use manifest-relative |
| -sample, camera and saved geometry paths, so raw sources are unnecessary. |
| -Prepare model-specific feature caches on the destination server using the |
| -existing SS or SLAT preparation commands. |
| +## Repository structure |
| |
| -Use `download --cleanup` to restore one archive at a time and remove it only |
| -after verification and successful extraction. This limits temporary archive |
| -storage to one shard while keeping the extracted dataset and small indices. |
| -The mixed training config `slat_segvigen/configs/one_hot_sum_flow_front3d_sage_32_nora_ray_pool.json` |
| -consumes these SAGE and 3D-FRONT roots, computing image features and pooling the |
| -saved 64³ grids to 32³ online. |
| +| Location | Contents | Default download | |
| +| --- | --- | --- | |
| +| `training/observations/<dataset>/` | Original sample NPZ files, calibration, object mappings, and scene voxel targets | Yes | |
| +| `training/shape/32/<dataset>/` | Complete object shape targets with explicit exclusions | Yes, when available | |
| +| `training/index.json` | Dataset recipes, sizes, monitoring counts, and source identities | Yes | |
| +| `optional/held_out/<dataset>/` | Remaining test observations | No | |
| +| `optional/geometry/<dataset>/` | Mesh geometry for evaluation and target generation | No | |
| +| `optional/occlusion/<dataset>/` | GT occlusion relations for applicable SS configurations | No | |
| +| `optional/evaluation/ycbv/` | YCB-V observations and geometry for evaluation | No | |
| +| `_deprecated/20261020/` | Previous bundles, inventories, and catalogs | No | |
| +| `code/` | Restore changes relative to the recorded Git revision | Bootstrap only | |
| |
| -## Exports for training without meshes |
| +Default datasets are 3D-FRONT and SAGE-10k. |
| +FoundationPose requires an explicit dataset selection. |
| +Its observation bundle supports SS and segmentation, but contains no shape targets or mesh geometry. |
| |
| -Training can use saved observations and targets without original datasets or mesh files. |
| -The export preserves the source manifest, split definitions, sample bytes, and checksums. |
| -Historical geometry paths remain provenance entries, but training does not open those paths. |
| +## Restore on another server |
| |
| -Create a local export from a complete extent: |
| +The dataset card records the required Git revision and restore patch. |
| +Apply that patch to the recorded project checkout before using the new commands. |
| +Install the project dependencies with its configured Python environment. |
| |
| ```bash |
| -python -m preprocess.training_export \ |
| - --dataset datasets/3dfront/extent/point_cloud \ |
| - --output datasets/3dfront/training/point_cloud |
| +python -m pip install -e '.[preprocess,ss-multiobj-depth,slat-segvigen,slat-multiobj-shape]' |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed |
| ``` |
| |
| -The exporter uses hard links on the same filesystem and copies files when necessary. |
| -The destination contains ordinary files and does not depend on source paths. |
| -It includes complete GT occlusion relations when they exist. |
| -It excludes mesh geometry and model-specific feature caches. |
| -The separate `training_export.json` records completion without changing the source manifest. |
| +The command downloads both default datasets and their 32³ object shape targets. |
| +It excludes optional and deprecated folders. |
| +It verifies each archive before extraction and removes temporary archives after restoration. |
| +Use `--keep-archives` only when you need those temporary files. |
| +Temporary transfer files use `datasets/_deprecated/<dataset>/huggingface/`. |
| |
| -Create transferable archives without an intermediate dataset copy: |
| +Select one dataset with `--dataset`: |
| |
| ```bash |
| -python -m preprocess.huggingface pack \ |
| - --dataset 3dfront=datasets/3dfront/extent/point_cloud \ |
| - --artifact-kind extent-training \ |
| - --output outputs/huggingface/training_only |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset foundationpose |
| ``` |
| |
| -The existing archive downloader also restores these archives. |
| -Use a separate packaging directory to avoid mixing full and training exports. |
| -The archive index records `artifact_kind=extent-training` and `geometry_included=false`. |
| -The source dataset remains unchanged. |
| - |
| -SS with object attention also needs its matching GT occlusion cache. |
| -SLAT shape training needs encoded targets and conditioning caches in addition to dataset metadata. |
| -Mesh-based evaluation and new SLAT shape encoding require a full extent export. |
| -Model weights remain separate artifacts. |
| - |
| -## FoundationPose on another server |
| - |
| -Use [code revision `92ca3ee`](https://github.com/cube-c/PartProbe3D/commit/92ca3eea1dbec6e162e246858eb7bdb7f7fd0701) or a compatible later revision on `slat-shape`. |
| -The FoundationPose bundle preserves original RGB, depth, visible masks, cameras, object mapping, and complete per-object voxel occupancy at 64³. |
| -Its source manifest has SHA-256 `2c4dcd1cd1e2e56a0eb08f2f92da320f299729c8ce7a2f52828c272cbc1fa0ad`. |
| -The extracted files occupy 87.82 GB before filesystem overhead. |
| -The [verified inventory](https://huggingface.co/datasets/cubec/PartProbe3D-preprocessed/blob/073988c5b5e206570da67f57aada4a2f0ad94e95/bundles/foundationpose/index.json) contains 86 archives totaling 89.33 GB. |
| -The export excludes raw archives, meshes, model weights, image features, SLAT latents, and GT occlusion relations. |
| - |
| -The loaders resolve input paths relative to the restored dataset. |
| -Historical absolute paths remain provenance entries. |
| -SS preparation creates the union of complete occupancy for objects with supplied masks and excludes other object voxels. |
| - |
| -### Restore the data |
| - |
| -Use Python 3.12 and a compatible PyTorch/CUDA installation. |
| -Run these commands from the repository root. |
| - |
| -1. Install the project dependencies. |
| - |
| - ```bash |
| - python -m pip install -e '.[preprocess,ss-multiobj-depth,tracking]' |
| - ``` |
| - |
| -2. Restore the prepared observations and voxel targets. |
| - |
| - ```bash |
| - python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --dataset foundationpose --cleanup \ |
| - --revision 073988c5b5e206570da67f57aada4a2f0ad94e95 |
| - ``` |
| - |
| -3. Initialize the pinned Pixal3D source. |
| - |
| - ```bash |
| - git submodule update --init third_party/Pixal3D |
| - ``` |
| - |
| -`--cleanup` retains extracted data and removes each verified temporary archive. |
| -Allow at least 100 GB for data restoration, plus space for weights and model features. |
| -Use `--revision <Hub commit>` to retain one dataset snapshot. |
| - |
| -### Acquire SS weights |
| - |
| -All required weights for the following SS configuration are available from Hugging Face. |
| -The commands pin revisions with the same configuration and weight bytes as the verified local files. |
| -DINOv3 requires approved access to its [gated model repository](https://huggingface.co/facebook/dinov3-vitl16-pretrain-lvd1689m). |
| - |
| -1. Authenticate with an account that can download DINOv3. |
| - |
| - ```bash |
| - hf auth login |
| - ``` |
| - |
| -2. Download the native SS flow and decoder from [Pixal3D](https://huggingface.co/TencentARC/Pixal3D). |
| - |
| - ```bash |
| - hf download TencentARC/Pixal3D \ |
| - --revision b0cb2e1b794cab9aa0ac38a95d794a4d9337437f \ |
| - --local-dir checkpoints/Pixal3D \ |
| - --include 'ckpts/ss_flow_img_dit_1_3B_64_bf16.*' 'ckpts/ss_dec_conv3d_16l8_fp16.*' |
| - ``` |
| - |
| -3. Download the SS encoder and paired decoder from [TRELLIS](https://huggingface.co/microsoft/TRELLIS-image-large). |
| - |
| - ```bash |
| - hf download microsoft/TRELLIS-image-large \ |
| - --revision 25e0d31ffbebe4b5a97464dd851910efc3002d96 \ |
| - --local-dir checkpoints/TRELLIS \ |
| - --include 'ckpts/ss_enc_conv3d_16l8_fp16.*' 'ckpts/ss_dec_conv3d_16l8_fp16.safetensors' |
| - ``` |
| - |
| -4. Download DINOv3. |
| - |
| - ```bash |
| - hf download facebook/dinov3-vitl16-pretrain-lvd1689m \ |
| - --revision ea8dc2863c51be0a264bab82070e3e8836b02d51 \ |
| - --local-dir checkpoints/DINOv3 --include config.json model.safetensors |
| - ``` |
| - |
| -### Prepare features and train SS |
| - |
| -The [FoundationPose configuration](ss_multiobj_depth/configs/foundationpose.json) uses GT depth, `depth_embedding` voxel conditioning, global cross-attention, and rank-8 NoRA. |
| -It creates features under `outputs/ss_multiobj_depth/foundationpose/features` and preserves the saved training/test splits. |
| -It starts a new run with W&B online by default. |
| -Online logging requires W&B authentication. |
| -The setting `training.wandb_mode="disabled"` permits a local run without W&B. |
| - |
| -1. Prepare local features and encoded SS targets. |
| - |
| - ```bash |
| - python -m ss_multiobj_depth.prepare --config ss_multiobj_depth/configs/foundationpose.json |
| - ``` |
| - |
| -2. Start training. |
| - |
| - ```bash |
| - python -m ss_multiobj_depth.train --config ss_multiobj_depth/configs/foundationpose.json |
| - ``` |
| - |
| -This configuration needs no source archives, meshes, or additional dataset downloads. |
| -The `occlusion_object` variant additionally requires a matching GT occlusion cache. |
| -That cache requires mesh geometry during preparation and is absent from this FoundationPose bundle. |
| -A matching GT occlusion overlay can transfer separately without another download of the observation archives. |
| -New SLAT shape encoding and mesh-based evaluation also require geometry or separately transferred targets. |
| -Exact resume of an existing run requires its matching checkpoint, feature manifests, source hashes, and settings. |
| - |
| -## GT occlusion relations |
| - |
| -Separate archives under `precomputed_occlusion/` preserve the completed GT occlusion caches. |
| -The caches contain directed `[front, back]` relations from calibrated visible masks and posed GT mesh silhouettes. |
| -Each archive preserves the original matrices, completion records, and manifest bytes. |
| - |
| -| Dataset | Training views | Test views | Archives | Size, MB | |
| -| --- | ---: | ---: | ---: | ---: | |
| -| 3D-FRONT | 39,930 | 10,066 | 3 | 240.01 | |
| -| SAGE-10k | 17,456 | 1,952 | 3 | 103.45 | |
| -| Total | 57,386 | 12,018 | 6 | 343.46 | |
| - |
| -MB means decimal megabytes. |
| -The inventories at `precomputed_occlusion/<dataset>/index.json` record archive sizes and SHA-256 checksums. |
| -They also preserve the source policy and checksum of the matching extent manifest. |
| - |
| -### Download GT occlusion caches |
| +Add `--revision <Hub commit>` to retain one dataset snapshot. |
| +Restoration refuses to replace different existing data. |
| +Original extent manifests retain their bytes and SHA-256 identities. |
| +The separate `compact_training.json` identifies available views without changing those manifests. |
| |
| -Restore the matching extent datasets before these overlays. |
| -Run these commands from the repository root. |
| +## Training inputs |
| |
| -```bash |
| -python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_occlusion \ |
| - --dataset 3dfront --revision 88cdf8f0e880a33e7cafa580ee9722776f16aa28 --cleanup |
| -python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_occlusion \ |
| - --dataset sage --revision 88cdf8f0e880a33e7cafa580ee9722776f16aa28 --cleanup |
| -``` |
| +The observations contain every training view and the first 16 test views per dataset. |
| +These test views cover the existing eight-view and sixteen-view training monitors. |
| +The remaining test observations require an optional download. |
| +Training view order and source splits remain unchanged. |
| |
| -The commands restore `datasets/<dataset>/extent/point_cloud/occlusion/`. |
| -The downloader verifies each archive and refuses to replace different existing files. |
| -The dataset reader checks the extent manifest identity before reading GT relations. |
| +Each sample NPZ already contains RGB, depth, visible labels, and complete per-object occupancy. |
| +The compact export excludes separate RGB, mask, depth, overlay, and per-view voxel copies. |
| +SS monitoring reads RGB and labels directly from the sample NPZ. |
| +Scene voxel targets remain available because SS preparation reads them. |
| |
| -SS training with occlusion-aware object cross-attention reads these relations. |
| -SLAT shape tokens already have instance identities and require no occlusion matrix. |
| -Frozen image features and SLAT shape latents remain separate artifacts. |
| +Shape targets preserve all object arrays, including coordinates, instance identities, and overlapping tokens. |
| +The export excludes combined scene latents because the current shape objective uses object targets. |
| +It records the three failed SAGE views as explicit exclusions. |
| +These exclusions match the existing object-mean shape experiment. |
| +SS and segmentation retain those views. |
| |
| +The download does not contain model features or trained weights. |
| +SS preparation creates its local feature cache. |
| +Segmentation extracts image features during training. |
| +The `configure-shape` command creates an online configuration without a separate image-feature cache. |
| +It preserves the selected preset's model and optimization settings. |
| +The [SLAT preparation guide](preprocess/slat/HUGGING_FACE.md) describes both shape options. |
| |
| -### Publish GT occlusion caches |
| +## Optional downloads |
| |
| -Package the verified caches from the prepared extent roots: |
| +Restore observations before adding geometry, occlusion, or remaining test views. |
| +The YCB-V evaluation bundle includes its own observations and geometry. |
| +Select each optional component explicitly: |
| |
| ```bash |
| -python -m preprocess.huggingface pack --artifact-kind gt-occlusion \ |
| - --dataset 3dfront=datasets/3dfront/extent/point_cloud \ |
| - --dataset sage=datasets/sage/extent/point_cloud \ |
| - --output outputs/huggingface/gt_occlusion |
| -python -m preprocess.huggingface upload \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_occlusion \ |
| - --dataset 3dfront --dataset sage --output outputs/huggingface/gt_occlusion |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset sage --optional geometry |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset 3dfront --optional occlusion |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset sage --optional held-out |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed --dataset ycbv --optional evaluation |
| ``` |
| |
| -Packaging checks every matrix checksum and its completion record. |
| -The uploader publishes complete inventories after it verifies all remote archives. |
| +Geometry supports mesh scoring and shape encoding at other resolutions. |
| +GT occlusion relations support SS configurations with occlusion-aware object attention. |
| +The current shape tokens already identify their objects and require no GT occlusion matrix. |
| +The optional test overlay expands the available views without replacing training inputs. |
| |
| -## Additional SLAT targets |
| +## Deprecated uploads |
| |
| -The same repository provides separate 32³ SLAT targets under `precomputed_slat/`. |
| -The 3D-FRONT bundle covers 39,930 training views. The SAGE bundle covers 17,456 training views. |
| -Together, their ten archives contain 6.37 GiB of latent targets and metadata. |
| -The existing extent datasets supply the RGB images, masks, depth, and geometry. |
| - |
| -```bash |
| -python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_slat \ |
| - --dataset 3dfront --cleanup |
| -python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_slat \ |
| - --dataset sage --cleanup |
| -``` |
| - |
| -These commands restore `datasets/<dataset>/slat/32/targets/`. |
| -The snapshots retain partial scene encoding and three failed SAGE object targets. |
| -Frozen image features require separate preparation. |
| -See the [SLAT snapshot specification](preprocess/slat/HUGGING_FACE.md) for source revisions, coverage, and preparation steps. |
| -The [local restoration report](reports/huggingface_additional_slat_targets_20261017.md) records downloaded snapshots and verification results. |
| +The previous layout remains under `_deprecated/20261020/`. |
| +The original [snapshot](https://huggingface.co/datasets/cubec/PartProbe3D-preprocessed/tree/d13e577a7e71291ed94fa40e4297f54106577fbd) also remains accessible by revision. |
| +Default downloads never select these paths. |
| +An unfiltered Hugging Face snapshot download still includes every folder. |
| +Use the project downloader to avoid optional and deprecated data. |
| |
| ## Publication |
| |
| -The reusable publication commands produce approximately 1 GiB archive shards |
| -under `outputs/`, without modifying the source datasets: |
| - |
| -```bash |
| -python -m preprocess.huggingface pack \ |
| - --dataset ycbv=datasets/ycbv/extent/point_cloud \ |
| - --dataset 3dfront=datasets/3dfront/extent/point_cloud \ |
| - --output outputs/huggingface/preprocessed |
| -python -m preprocess.huggingface catalog \ |
| - --dataset 3dfront=datasets/3dfront/extent/point_cloud \ |
| - --dataset ycbv=datasets/ycbv/extent/point_cloud \ |
| - --repo cubec/PartProbe3D-preprocessed --output outputs/huggingface/preprocessed |
| -python -m preprocess.huggingface upload \ |
| - --dataset 3dfront --dataset ycbv --repo cubec/PartProbe3D-preprocessed \ |
| - --output outputs/huggingface/preprocessed --follow |
| -``` |
| - |
| -`--follow` uploads finished shards while packaging continues. Repeating the |
| -commands reuses verified packages and skips matching remote archives. The publisher uploads the complete archive index after it uploads all archives. |
| -Use `upload --workers 16` to request 16 concurrent archive transfers. |
| -The default retains the Hugging Face client's transfer settings. |
| -The initial run logs are `outputs/huggingface/preprocessed/pack.log`, |
| -`upload-3dfront.log`, and `upload-ycbv.log`. |
| - |
| -For one job that packages, uploads, retries transient Hub failures and updates |
| -the public dataset card, use: |
| - |
| -```bash |
| -python -m preprocess.huggingface publish \ |
| - --dataset ycbv=datasets/ycbv/extent/point_cloud \ |
| - --dataset 3dfront=datasets/3dfront/extent/point_cloud \ |
| - --repo cubec/PartProbe3D-preprocessed --output outputs/huggingface/preprocessed |
| -``` |
| - |
| -The job records `running`, `complete`, or `failed` in |
| -`outputs/huggingface/preprocessed/publish-status.json`. The detached server run |
| -records its process ID in `publish.pid` and writes `publish.log` in that folder. |
| - |
| -For large datasets, `publish --cleanup` creates, uploads and verifies one shard |
| -before removing it and creating the next. |
| -The command preserves original datasets, archive inventories, previews, transfer logs, and remote archives. |
| -Failures retain the current unverified shard. Repeating the command verifies |
| -existing remote archives and resumes the upload. |
| -The publisher can rebuild removed staging shards from the unchanged source. Existing dataset catalogs remain in the repo: |
| +Run this command from the project root: |
| |
| ```bash |
| -python -m preprocess.huggingface publish \ |
| - --dataset sage=datasets/sage/extent/point_cloud \ |
| +python -m preprocess.reproduction publish \ |
| --repo cubec/PartProbe3D-preprocessed \ |
| - --output outputs/huggingface/preprocessed --cleanup |
| + --output outputs/huggingface/reproduction \ |
| + --dataset 3dfront --dataset sage --dataset foundationpose |
| ``` |
| |
| -## SS targets for masked objects |
| - |
| -The prepared dataset already contains complete per-object occupancy and the prompt mapping. |
| -SS target generation uses the saved labels and prompt mapping. |
| -It creates new local targets and encoded latents. |
| -The published dataset retains its existing files. Existing local copies need no additional dataset download. |
| - |
| -See [SS target regeneration and transfer](ss_multiobj_depth/README.md#regenerate-targets-for-masked-objects) for target overlays and reuse of existing conditioning caches. |
| +Publication preserves source datasets and limits temporary archive storage through verified upload batches. |
| +Repetition reuses remote archives with matching SHA-256 identities. |
| +The publisher retains unverified files after a failure. |
| |
| |
| |
| |
| @@ -110,6 +110,18 @@ class ViewDataset: |
| if not self.manifest["complete"] and not allow_incomplete: |
| raise ValueError("Conversion is incomplete; do not use partial data for training") |
| self.views = [row for row in self.manifest["views"] if split is None or row["split"] == split] |
| + selection_path = self.root / 'compact_training.json' |
| + if selection_path.exists(): |
| + from utils.hashing import sha256 |
| + selection = json.loads(selection_path.read_text()) |
| + ids = selection.get('view_ids', []) |
| + if (selection.get('schema') != 'partprobe3d.compact-training.v1' |
| + or selection.get('source_manifest_sha256') != sha256(self.root / 'manifest.json') |
| + or len(ids) != len(set(ids)) |
| + or set(ids) - {row['id'] for row in self.manifest['views']}): |
| + raise ValueError('Compact training selection differs from the source manifest') |
| + available = set(ids) |
| + self.views = [row for row in self.views if row['id'] in available] |
| |
| def __len__(self): |
| return len(self.views) |
| |
| |
| |
| |
| @@ -31,6 +31,10 @@ class ExtentLoader(BaseDataLoader): |
| from PIL import Image |
| index = self.dataset._index(index) |
| row = self.rows[index] |
| + if (self.root / 'compact_training.json').exists(): |
| + # Load only these two NPZ members. Calibration and depth stay unread. |
| + with np.load(self.root / row['sample'], allow_pickle=False) as arrays: |
| + return arrays['rgb'], arrays['image_labels'].astype(np.int32) + 1 |
| with Image.open(self.root / row["rgb"]) as image: |
| rgb = np.array(image.convert("RGB")) |
| objects = self.dataset.source.objects(self.dataset.indices[index])["prompts"] |
| |
| |
| |
| |
| @@ -8,6 +8,7 @@ import os |
| from pathlib import Path, PurePosixPath |
| import re |
| import shutil |
| +import stat |
| import tarfile |
| import tempfile |
| import time |
| @@ -90,8 +91,13 @@ class _HashWriter: |
| return self.stream.write(data) |
| |
| |
| -def _archive(path, files, source, destination, previous=None): |
| - records = [(str(p.relative_to(source)), p.stat().st_size, p.stat().st_mtime_ns) for p in files] |
| +def _archive(path, files, source, destination, previous=None, *, checksums=None): |
| + records = [] |
| + for file in files: |
| + original = file.stat(follow_symlinks=False) |
| + if not stat.S_ISREG(original.st_mode): |
| + raise ValueError(f'Archive sources must be regular files: {file}') |
| + records.append((str(file.relative_to(source)), original.st_size, original.st_mtime_ns)) |
| identity = hashlib.sha256(json.dumps(records).encode()).hexdigest() |
| if previous and previous.get('identity') == identity and path.is_file(): |
| if path.stat().st_size == previous['bytes'] and sha256(path) == previous['sha256']: |
| @@ -101,18 +107,36 @@ def _archive(path, files, source, destination, previous=None): |
| try: |
| with temporary.open('wb') as stream: |
| writer = _HashWriter(stream) |
| - with tarfile.open(fileobj=writer, mode='w|', format=tarfile.USTAR_FORMAT) as archive: |
| + with tarfile.open(fileobj=writer, mode='w|', format=tarfile.USTAR_FORMAT, |
| + bufsize=256 * 1024, copybufsize=1024**2) as archive: |
| for file, (name, size, mtime) in zip(files, records): |
| - info = archive.gettarinfo(str(file), arcname=str(destination / name)) |
| - if not info.isfile() or info.size != size or file.stat().st_mtime_ns != mtime: |
| - raise ValueError(f'Source changed during packaging: {file}') |
| + info = tarfile.TarInfo(str(destination / name)) |
| + info.size = size |
| info.uid = info.gid = info.mtime = 0 |
| info.uname = info.gname = '' |
| info.mode = 0o644 |
| with file.open('rb') as data: |
| - archive.addfile(info, data) |
| - if file.stat().st_mtime_ns != mtime or file.stat().st_size != size: |
| - raise ValueError(f'Source changed during packaging: {file}') |
| + opened = os.fstat(data.fileno()) |
| + if opened.st_size != size or opened.st_mtime_ns != mtime: |
| + raise ValueError(f'Source changed during packaging: {file}') |
| + if checksums and file in checksums: |
| + class CheckedReader: |
| + def __init__(self, stream): |
| + self.stream, self.digest = stream, hashlib.sha256() |
| + |
| + def read(self, size=-1): |
| + block = self.stream.read(size) |
| + self.digest.update(block) |
| + return block |
| + checked = CheckedReader(data) |
| + archive.addfile(info, checked) |
| + if checked.digest.hexdigest() != checksums[file]: |
| + raise ValueError(f'Source checksum changed during packaging: {file}') |
| + else: |
| + archive.addfile(info, data) |
| + finished = os.fstat(data.fileno()) |
| + if finished.st_mtime_ns != mtime or finished.st_size != size: |
| + raise ValueError(f'Source changed during packaging: {file}') |
| stream.flush() |
| os.fsync(stream.fileno()) |
| digest = writer.digest.hexdigest() |
| @@ -378,7 +402,7 @@ def extract(index, folder, destination): |
| path = folder / _relative(item['file']) |
| if path.stat().st_size != item['bytes'] or sha256(path) != item['sha256']: |
| raise ValueError(f'Archive checksum mismatch: {path}') |
| - with tarfile.open(path, 'r|') as archive: |
| + with tarfile.open(path, 'r|', bufsize=256 * 1024) as archive: |
| for member in archive: |
| relative = _relative(member.name) |
| if not relative.is_relative_to(prefix) or not member.isfile(): |
| @@ -401,6 +425,9 @@ def extract(index, folder, destination): |
| finally: |
| temporary.unlink(missing_ok=True) |
| print(f"RESTORED {index['name']}/{item['file']}", flush=True) |
| + if index.get('artifact_kind') in ('compact-training', 'held-out-observations'): |
| + from preprocess.reproduction import refresh_selection |
| + refresh_selection(destination / restored_prefix) |
| return destination / restored_prefix |
| |
| |
| @@ -523,14 +550,21 @@ def upload(output, repo, names, *, follow=False, packing=None, update_card=False |
| print(f'UPLOADED {name}: https://huggingface.co/datasets/{repo}', flush=True) |
| |
| |
| -def download(repo, name, destination, revision, *, cleanup=False, bundle_root='bundles'): |
| +def download(repo, name, destination, revision, *, cleanup=None, bundle_root=None): |
| + if bundle_root is None: |
| + from preprocess.reproduction import download_training |
| + return download_training(repo, name, destination, revision, cleanup=cleanup is not False) |
| from huggingface_hub import HfApi, hf_hub_download |
| from utils.huggingface_download import download_huggingface_file |
| # Resolve main once so all archives and the index belong to one snapshot. |
| revision = HfApi().dataset_info(repo, revision=revision).sha |
| bundle_root = str(_relative(bundle_root)) |
| destination = Path(destination).resolve() |
| - cache = destination / 'datasets' / name / 'archives' / 'huggingface' |
| + # Keep active training folders free of transfer archives. Retain the legacy |
| + # cache path only when an explicit historical component needs resume. |
| + cache = (destination / 'datasets' / '_deprecated' / name / 'huggingface' |
| + if bundle_root.startswith(('training/', 'optional/')) |
| + else destination / 'datasets' / name / 'archives' / 'huggingface') |
| index_path = hf_hub_download(repo, f'{bundle_root}/{name}/index.json', repo_type='dataset', |
| revision=revision, local_dir=cache) |
| index = _json(index_path) |
| @@ -820,12 +854,16 @@ def main(): |
| help='Concurrent archive transfers. Default: Hugging Face client setting') |
| restoring = commands.add_parser('download') |
| restoring.add_argument('--repo', required=True) |
| - restoring.add_argument('--dataset', required=True) |
| + restoring.add_argument('--dataset', default='all', help='Dataset name. Default: 3D-FRONT and SAGE') |
| restoring.add_argument('--destination', type=Path, default=Path('.')) |
| restoring.add_argument('--revision', default='main') |
| - restoring.add_argument('--bundle-root', default='bundles') |
| + restoring.add_argument('--bundle-root', default=None, |
| + help='Explicit component root. Default: compact training data and 32-cubed shape targets') |
| restoring.add_argument('--cleanup', action='store_true', |
| help='Restore one archive at a time and remove it after successful extraction') |
| + restoring.add_argument('--keep-archives', action='store_true', help='Retain temporary archives after restoration') |
| + restoring.add_argument('--optional', choices=('geometry', 'occlusion', 'held-out', 'evaluation'), |
| + help='Download only this optional component for the selected dataset') |
| describing = commands.add_parser('catalog') |
| describing.add_argument('--dataset', action='append', required=True, metavar='NAME=EXTENT_ROOT') |
| describing.add_argument('--output', type=Path, required=True) |
| @@ -853,8 +891,14 @@ def main(): |
| publish(args.output, dict(dataset.split('=', 1) for dataset in args.dataset), args.repo, |
| cleanup=args.cleanup) |
| else: |
| - download(args.repo, args.dataset, args.destination, args.revision, cleanup=args.cleanup, |
| - bundle_root=args.bundle_root) |
| + if args.optional and args.bundle_root: |
| + parser.error('--optional and --bundle-root cannot be combined') |
| + bundle_root = f'optional/{args.optional.replace("-", "_")}' if args.optional else args.bundle_root |
| + if args.optional and args.dataset == 'all': |
| + parser.error('Select one dataset with --dataset for an optional download') |
| + cleanup = not args.keep_archives if bundle_root is None or args.optional else args.cleanup |
| + download(args.repo, args.dataset, args.destination, args.revision, cleanup=cleanup, |
| + bundle_root=bundle_root) |
| |
| |
| if __name__ == '__main__': |
| |
| |
| |
| |
| @@ -1,145 +1,99 @@ |
| -## SLAT shape: upload and download specification |
| - |
| -The repository contains prepared extent datasets and separate SLAT-shape targets. |
| -Combined 32³ SLAT finetuning requires both artifact types for both training datasets. |
| -The 6.84 GB SLAT upload contains latent targets and metadata. |
| -It excludes RGB observations, depth maps, masks, and frozen image features. |
| - |
| -The sizes and coverage below describe data snapshot `0e4623fb0c8d9bad7cbe1dfb161a993ac165b6aa`. |
| -GB means decimal gigabytes. |
| - |
| -| Bundle | Contents | Training archives and metadata, GB | All archives, GB | |
| -| --- | --- | ---: | ---: | |
| -| `bundles/3dfront` | Calibrated observations, extent geometry, and occupancy targets | 234.67 | 293.70 | |
| -| `bundles/sage` | Calibrated observations, extent geometry, and occupancy targets | 460.59 | 510.88 | |
| -| `precomputed_slat/3dfront` | 32³ object latents and available scene latents | 5.57 | 5.57 | |
| -| `precomputed_slat/sage` | 32³ object latents and recorded failures | 1.27 | 1.27 | |
| -| Total | Both datasets and both artifact types | 702.10 | 811.42 | |
| - |
| -Training requires each extent bundle's `metadata.tar` and `train-*.tar` archives. |
| -Evaluation also requires its `test-*.tar` archives. |
| -The current download command restores every archive in a bundle, including available test archives. |
| -It has no split filter. |
| -The four commands below therefore download about 811.42 GB. |
| - |
| -### Download and restore |
| - |
| -Use the updated PartProbe3D checkout with latent generation in `preprocess/slat/`. |
| -Install its preprocessing dependencies and `huggingface-hub`. |
| -Authenticate with a Hugging Face account that can access this dataset repository. |
| -Run these commands from the repository root. |
| - |
| -1. Restore the prepared 3D-FRONT extent dataset. |
| - |
| - ```bash |
| - python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root bundles \ |
| - --dataset 3dfront --revision 0e4623fb0c8d9bad7cbe1dfb161a993ac165b6aa --cleanup |
| - ``` |
| - |
| -2. Restore the prepared SAGE-10k extent dataset. |
| - |
| - ```bash |
| - python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root bundles \ |
| - --dataset sage --revision 0e4623fb0c8d9bad7cbe1dfb161a993ac165b6aa --cleanup |
| - ``` |
| - |
| -3. Restore the 3D-FRONT shape targets. |
| - |
| - ```bash |
| - python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_slat \ |
| - --dataset 3dfront --revision 0e4623fb0c8d9bad7cbe1dfb161a993ac165b6aa --cleanup |
| - ``` |
| - |
| -4. Restore the SAGE-10k shape targets. |
| - |
| - ```bash |
| - python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_slat \ |
| - --dataset sage --revision 0e4623fb0c8d9bad7cbe1dfb161a993ac165b6aa --cleanup |
| - ``` |
| - |
| -| Dataset | Prepared observations and extent targets | SLAT targets | |
| -| --- | --- | --- | |
| -| 3D-FRONT | `datasets/3dfront/extent/point_cloud/` | `datasets/3dfront/slat/32/targets/` | |
| -| SAGE-10k | `datasets/sage/extent/point_cloud/` | `datasets/sage/slat/32/targets/` | |
| - |
| -The updated downloader maps historical SLAT archive paths under `outputs/` to these dataset locations. |
| -It preserves target bytes and verifies every archive's size and SHA-256 checksum. |
| -It refuses to replace different existing files. |
| -`--cleanup` retains one temporary archive at a time and removes it after successful restoration. |
| -Temporary archives reside under `datasets/<dataset>/archives/huggingface/`. |
| -Extracted files and future feature caches need additional disk space. |
| - |
| -Preserve the original extent manifests without edits. |
| -The SLAT manifests bind their source datasets through manifest checksums. |
| -Raw dataset archives, rendering again, and SS feature caches are unnecessary for this workflow. |
| - |
| -### Complete preparation before training |
| - |
| -The published targets cover 39,930 3D-FRONT training views and 17,456 SAGE-10k training views. |
| -Three SAGE-10k views retain one failed object target each. |
| -These failures block strict combined training until object encoding succeeds. |
| -The snapshot contains scene latents for 6,720 3D-FRONT views and no SAGE-10k scenes. |
| -The current object loss does not require completed scene encoding. |
| - |
| -1. Obtain the configured Pixal3D, DINOv3, and NAF weights separately. |
| -2. Resolve the three failed SAGE-10k object targets. |
| -3. Prepare frozen conditioning features and immutable object targets. |
| -4. Start finetuning after feature preparation succeeds. |
| - |
| -The TRELLIS.2 shape encoder and paired decoder are also required when regenerating shape targets. |
| -Image features and immutable training snapshots are not included in the uploaded target bundles. |
| -The commands below do not automatically schedule scene encoding or training during feature preparation. |
| +# SLAT shape reproduction data |
| + |
| +The public dataset provides compact observations and separate 32³ object shape targets. |
| +The [dataset guide](../../HF_DATASETS.md) describes restoration and optional components. |
| +The default restore command includes both artifact types for 3D-FRONT and SAGE-10k. |
| |
| ```bash |
| -python -m preprocess.slat.prepare \ |
| - --config preprocess/slat/configs/front3d_sage_32.json \ |
| - --stage features --devices cuda:1 cuda:2 |
| -python -m slat_multiobj_shape.train \ |
| - --config slat_multiobj_shape/configs/front3d_sage_32.json |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed |
| ``` |
| |
| -Feature preparation writes `object_targets/` and `object_features/` under each dataset's `slat/32/` directory. |
| -It retains clean GT depth for fresh augmentation during training. |
| -Testing uses MoGe-3 depth and calibration. |
| -Training results reside under `outputs/`, and model checkpoints reside under `checkpoints/`. |
| +## Restored locations |
| + |
| +| Artifact | Location | |
| +| --- | --- | |
| +| Saved observations and occupancy | `datasets/<dataset>/extent/point_cloud/` | |
| +| Object shape targets | `datasets/<dataset>/slat/32/targets/` | |
| +| Optional geometry | `datasets/<dataset>/extent/point_cloud/scenes/` | |
| + |
| +The extent manifests retain their original bytes and source splits. |
| +Each shape manifest binds those extent manifests by SHA-256. |
| +Each successful object retains its original latent values, cell coordinates, object index, and transform. |
| +The `object_sha256` identity checks those arrays independently of scene encoding. |
| + |
| +The current objective uses separate object latents. |
| +It does not require combined scene latents or scene encoding. |
| +The compact targets retain empty scene fields for the existing file schema. |
| +Use configurations with `require_scene_targets=false`. |
| + |
| +## SAGE exclusions |
| + |
| +The original release contains three failed object targets. |
| +The compact release records their views as explicit exclusions: |
| + |
| +- `sage10k/23adeb2d2638a873e5d9` |
| +- `sage10k/7b2d68afd83bf89364ea` |
| +- `sage10k/ff0a565cad070014b1b8` |
| + |
| +These exclusions match the existing object-mean shape experiment. |
| +The exported shape manifest makes them available to every compatible shape preset. |
| +Shape training therefore uses 39,930 3D-FRONT views and 17,453 SAGE views. |
| +SS and segmentation still use all 17,456 SAGE training views. |
| |
| -### Upload contract |
| +## Train without an image-feature cache |
| |
| -`bundles/<dataset>/index.json` describes prepared extent archives. |
| -`precomputed_slat/<dataset>/index.json` describes SLAT target archives. |
| -Each inventory records archive sizes, SHA-256 checksums, and the restore destination. |
| -SLAT inventories also record source manifests, codec provenance, coverage, and encoding failures. |
| +Obtain the configured Pixal3D, DINOv3, and NAF weights separately. |
| +Create an online configuration from the project root: |
| |
| -An inventory's `complete=true` means packaging covers the snapshot files. |
| -The uploader publishes a complete inventory after every archive is present with matching size. |
| -It also compares remote SHA-256 checksums when Hub file metadata provides them. |
| -`source_complete` separately records whether source preprocessing finished. |
| -An upload can therefore finish while source object or scene encoding remains incomplete. |
| -The upload preserves failure records and pending scene statuses. |
| +```bash |
| +python -m preprocess.reproduction configure-shape --output outputs/reproduction/shape_online.json |
| +CUDA_VISIBLE_DEVICES=4,6 CUDA_DEVICE_ORDER=PCI_BUS_ID \ |
| + python -m slat_multiobj_shape.train \ |
| + --config outputs/reproduction/shape_online.json |
| +``` |
| + |
| +This configuration reads the uploaded object targets and computes image conditioning during training. |
| +It avoids separate image-feature files and frozen target copies. |
| +It preserves the selected preset's model, sampling, and optimizer settings. |
| +It uses separate output and checkpoint directories. |
| +Use the original cached preset when reproducing a cached-feature experiment. |
| + |
| +## Train with cached image features |
| |
| -Package shape targets with this command: |
| +Prepare the existing assigned-object caches with: |
| |
| ```bash |
| -python -m preprocess.huggingface pack \ |
| - --artifact-kind slat-shape-targets \ |
| - --dataset 3dfront=datasets/3dfront/slat/32/targets \ |
| - --dataset sage=datasets/sage/slat/32/targets \ |
| - --output outputs/huggingface/slat_targets_publish |
| +CUDA_VISIBLE_DEVICES=4,6 CUDA_DEVICE_ORDER=PCI_BUS_ID \ |
| + python -m preprocess.slat.prepare \ |
| + --config preprocess/slat/configs/front3d_sage_32_assigned_object.json \ |
| + --stage features --devices cuda:0 cuda:1 |
| +CUDA_VISIBLE_DEVICES=4,6 CUDA_DEVICE_ORDER=PCI_BUS_ID \ |
| + python -m slat_multiobj_shape.train \ |
| + --config slat_multiobj_shape/configs/front3d_sage_32_assigned_object.json |
| ``` |
| |
| -Publish those archives to an existing dataset repository with this command: |
| +Feature preparation needs observations, object shape targets, and the configured image encoders. |
| +It does not need source meshes or the shape encoder. |
| +The generated feature files and frozen target snapshots consume additional local storage. |
| + |
| +## Optional geometry |
| + |
| +Geometry is necessary when generating new shape targets or scoring decoded meshes. |
| +Download it explicitly before these operations: |
| |
| ```bash |
| -python -m preprocess.huggingface upload \ |
| - --repo cubec/PartProbe3D-preprocessed \ |
| - --bundle-root precomputed_slat --dataset 3dfront --dataset sage \ |
| - --output outputs/huggingface/slat_targets_publish |
| +python -m preprocess.huggingface download \ |
| + --repo cubec/PartProbe3D-preprocessed --dataset 3dfront --optional geometry |
| +python -m preprocess.huggingface download \ |
| + --repo cubec/PartProbe3D-preprocessed --dataset sage --optional geometry |
| ``` |
| |
| -The target upload excludes worker jobs, raw assets, model weights, and frozen image feature caches. |
| -Use a fresh packaging directory when source manifests change. |
| -Publish matching extent and target snapshots before documenting a new reproducible data revision. |
| +New encoding also needs the configured shape encoder and paired decoder. |
| +The public compact shape targets use a 32³ grid. |
| +Their encoder uses a 512³ geometry grid and produces 32 channels per latent cell. |
| + |
| +## Historical snapshots |
| + |
| +The original targets remain in the deprecated folder and the original pinned revisions. |
| +The [original upload report](../../reports/slat_targets_huggingface_20261015.md) records their coverage and codec identities. |
| +Exact checkpoint resume requires the checkpoint's original data and feature identities. |
| |
| |
| |
| |
| @@ -1,7 +1,7 @@ |
| # SLAT preparation |
| |
| This stage prepares reusable training inputs for multi-object SLAT shape finetuning. |
| -It reads the saved 3D-FRONT and SAGE-10k extent datasets after capture and voxel export. |
| +It reads saved extent datasets from 3D-FRONT, SAGE-10k, and FoundationPose after capture and voxel export. |
| It preserves each saved cube, object identity, and room or layout split. |
| |
| The generation implementation and its configurations reside in this package. |
| @@ -11,6 +11,95 @@ The generation implementation and its configurations reside in this package. |
| | `targets.py` | Select posed meshes, preserve the saved cube, and write object and scene targets | |
| | `encode.py` | Convert meshes to dual grids and apply the frozen pretrained shape encoder | |
| | `prepare.py` | Coordinate dataset phases and extract frozen conditioning features | |
| +| `scene_targets.py` | Export one scene token per reference voxel with an explicit latent validity flag | |
| + |
| +## Aligned scene targets at 32³ |
| + |
| +The scene export combines complete meshes for all prompted objects before one frozen shape encoder processes them. |
| +It preserves each training view's saved cube, calibration, object order, and dataset split. |
| +Different views of one room can use different cubes. |
| +The export therefore retains each view ID. |
| + |
| +Reference voxels are the union of complete occupancy for prompted objects. |
| +The shared `prompt_object_cells` function selects these voxels from saved 64³ targets and pools them to 32³. |
| +Unprompted objects do not add reference voxels. |
| +Older feature caches can contain extra scene voxels from unprompted objects. |
| +Those extra rows do not define the reference occupancy for this export. |
| + |
| +Each reference voxel has exactly one scene token, including voxels that contain multiple objects. |
| +The native scene encoder can omit a small number of reference voxels because its rasterization method differs. |
| +The export retains those coordinates with zero feature storage and `latent_valid=false`. |
| +Training must exclude invalid rows from the latent loss. |
| +The export does not average object latents or interpolate missing values. |
| + |
| +| Array | Shape | Meaning | |
| +| --- | --- | --- | |
| +| `coords` | `[N, 3]` | Unique reference coordinates in sorted order, stored as `uint8` | |
| +| `feats` | `[N, 32]` | Physical scene latents stored as `float16`, with zeros at invalid rows | |
| +| `latent_valid` | `[N]` | Boolean flag for an exact coordinate match with native scene encoding | |
| +| `memberships` | `[N, K]` | Independent per-object voxel occupancy for the same reference rows | |
| +| `object_ids` | `[K]` | Prompt identities in the saved order | |
| +| `model_to_world` | `[4, 4]` | Original transform from the normalized cube to world coordinates | |
| + |
| +Multiple columns of `memberships` can be positive at one voxel. |
| +They do not create additional scene tokens. |
| + |
| +Run the combined export from the repository root: |
| + |
| +```bash |
| +python -m preprocess.slat.scene_targets \ |
| + --config preprocess/slat/configs/scenes_32.json |
| +``` |
| + |
| +The configuration selects training views only and uses GPUs 0, 1, and 2. |
| +Sixteen CPU processes prepare meshes for six persistent GPU workers. |
| +Each GPU hosts two encoder processes. |
| +Each GPU worker uses four CPU threads to prepare native dual grids while the GPU encodes earlier grids. |
| +The `mesh_workers` and `raster_workers` settings control these CPU counts. |
| +The latter count applies separately to each GPU worker. |
| +The `mesh_executor` setting selects CPU processes or threads. |
| +CPU processes avoid Python thread contention during mesh preparation. |
| +They transfer geometry and reference metadata without RGB or depth tensors. |
| +Prefetch retains a bounded number of grids in memory. |
| + |
| +Mesh clipping omits plane cuts when all vertices lie strictly inside the plane. |
| +Vertices near a clipping plane retain the original Trimesh procedure. |
| +These changes preserve the cube, rasterization settings, encoder weights, and reference voxels. |
| + |
| +Its `encoder_config` selects the existing codec weights, dual-grid settings, and native Python environment. |
| +Each dataset saves its targets under `datasets/<dataset>/slat/32/scene_targets/`. |
| +The format identifier is `slat-scene-targets-v1`. |
| +Logs and combined progress reside under `outputs/slat_scene/32/preparation/`. |
| + |
| +The export reuses completed native scene encodings after it checks their dataset, cube, prompts, codec, and file checksums. |
| +Existing object caches retain their original files. |
| +Per-view completion records support resume after an interruption. |
| +Resume retries failed encodings and replaces corrupt output files. |
| + |
| +Add `--limit-per-dataset 2` for a short GPU check. |
| +Repeat the command without that argument to complete every training view. |
| +The command finishes active jobs before it honors SIGINT or SIGTERM. |
| +The default storage reserve stops preparation if free space falls below 20 GiB. |
| + |
| +`dataloader.slat_scene.SceneTargetDataset` reads one or more exported caches without loading meshes. |
| +It checks exact reference coordinates, occupancy labels, object identities, and cube transforms against the saved extent views. |
| +It normalizes valid latents with the pretrained flow statistics and keeps invalid rows zero. |
| + |
| +### Test native latent equivalence |
| + |
| +Run the regression with the actual pretrained encoder: |
| + |
| +```bash |
| +PARTPROBE3D_NATIVE_SLAT_TEST=1 python -m pytest \ |
| + preprocess/tests/test_slat_native_equivalence.py -q |
| +``` |
| + |
| +This test requires the native CUDA environment and existing codec checkpoints. |
| +Set `PARTPROBE3D_NATIVE_SLAT_DEVICE` to select a GPU other than `cuda:0`. |
| +The test compares original serial preparation with optimized clipping and four CPU threads for rasterization. |
| +It covers inside meshes, clipped meshes, and overlapping objects encoded together. |
| +It requires identical coordinates and identical stored `float16` latents with zero tolerance. |
| +The normal test suite skips this GPU test unless the environment flag enables it. |
| |
| ## Prepared data |
| |
| @@ -84,8 +173,8 @@ Scene encoding preserves object failures and includes their selected meshes in t |
| Failed objects still require successful encoding before feature extraction or finetuning. |
| |
| Resume preserves completed object and scene latents. |
| -The cached training configurations supervise objects and do not require scene targets. |
| -Configurations with `require_scene_targets=true` retain scene supervision in their feature caches. |
| +All shape training configurations supervise object latents only. |
| +Feature caches exclude scene supervision, while target exports retain scene latents for diagnostics. |
| |
| 1. Prepare targets and features for both training datasets. |
| |
| @@ -181,42 +270,31 @@ Training resume also checks cache provenance and latent target checksums. |
| |
| ## Hugging Face snapshots |
| |
| -The [upload and download specification](HUGGING_FACE.md) lists training dependencies, archive sizes, restoration commands, and publication requirements. |
| - |
| -The [preprocessed dataset repository](https://huggingface.co/datasets/cubec/PartProbe3D-preprocessed/tree/main/precomputed_slat) contains separate snapshots of the available 32³ shape targets. |
| -The snapshots preserve the original manifests, per-view checksums, object identities, and completion states. |
| -They cover training views only. |
| -Frozen DINOv3 and NAF feature caches still require preparation. |
| - |
| -| Dataset | Training views | Encoded objects | Failed objects | Completed scene views | Pending scene views | |
| -| --- | ---: | ---: | ---: | ---: | ---: | |
| -| 3D-FRONT | 39,930 | 240,952 | 0 | 6,720 | 33,210 | |
| -| SAGE-10k | 17,456 | 397,203 | 3 | 0 | 17,456 | |
| - |
| -These counts describe the published snapshot. |
| -Three SAGE-10k views retain one failed object each. |
| -Pending scene records remain pending after restoration. |
| -An archive's completion flag describes packaging and transfer, not completion of source preprocessing. |
| - |
| -Restore both caches from the repository root: |
| +The [reproduction guide](HUGGING_FACE.md) describes the active compact observations and 32³ object shape targets. |
| +The default download restores both artifact types for 3D-FRONT and SAGE-10k. |
| +It excludes optional components and deprecated uploads. |
| |
| ```bash |
| -python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_slat \ |
| - --dataset 3dfront --cleanup |
| -python -m preprocess.huggingface download \ |
| - --repo cubec/PartProbe3D-preprocessed --bundle-root precomputed_slat \ |
| - --dataset sage --cleanup |
| +python -m preprocess.huggingface download --repo cubec/PartProbe3D-preprocessed |
| ``` |
| |
| -The first command restores `datasets/3dfront/slat/32/targets/`. |
| -The second command restores `datasets/sage/slat/32/targets/`. |
| -The downloader maps historical archive paths to these dataset locations. |
| -Restoration verifies archive checksums and rejects replacement of different existing files. |
| -Add `--revision <commit>` to select a fixed Hub snapshot. |
| +The observations restore under `datasets/<dataset>/extent/point_cloud/`. |
| +The object targets restore under `datasets/<dataset>/slat/32/targets/`. |
| +The extent manifests retain their original bytes and SHA-256 identities. |
| +Object arrays retain their latent values, coordinates, instance identities, and transforms. |
| + |
| +Shape training uses 39,930 3D-FRONT views and 17,453 SAGE views. |
| +The shape manifest explicitly excludes the three failed SAGE views from the existing experiment. |
| +The compact shape export omits combined scene latents because the current object loss does not use them. |
| +Original snapshots remain under `_deprecated/20261020/` and their pinned revisions. |
| + |
| +Add `--revision <Hub commit>` to select a fixed release. |
| +Restoration checks archive hashes and refuses to replace different existing data. |
| +The downloader removes temporary archives after successful extraction. |
| |
| -The corresponding extent datasets remain in the repository's `bundles/` directory. |
| -Shape target loaders require those source datasets and matching manifests. |
| +Image features require local preparation or online extraction during training. |
| +Mesh geometry requires an explicit `--optional geometry` download for target regeneration or mesh scoring. |
| +See the reproduction guide for the online shape configuration and cached feature commands. |
| |
| ## Training and testing |
| |
| |
| |
| |
| |
| @@ -28,11 +28,16 @@ def _validate_view(root, row): |
| sample = vd.canonical_sample(vd.load_npz(root / row['sample']), gt) |
| folder = root / row['view_directory'] |
| stamp = json.loads((folder / 'complete.json').read_text()) |
| + compact = (root / 'compact_training.json').exists() |
| + required = {Path(row['sample']).name, Path(row['camera']).name, 'objects.json'} |
| for filename, checksum in stamp['sha256'].items(): |
| + if compact and filename not in required: |
| + continue |
| if sha256(folder / filename) != checksum: |
| raise ValueError(f'Checksum mismatch: {folder / filename}') |
| - with Image.open(folder / 'rgb.png') as im: |
| - np.testing.assert_array_equal(np.asarray(im), sample['rgb']) |
| + if not compact: |
| + with Image.open(folder / 'rgb.png') as im: |
| + np.testing.assert_array_equal(np.asarray(im), sample['rgb']) |
| for name, key in (('instance_labels.png', 'image_labels'), |
| ('support_instance_labels.png', 'all_image_labels')): |
| if (folder / name).exists(): |
| @@ -50,8 +55,11 @@ def _validate_view(root, row): |
| table = json.loads((folder / 'objects.json').read_text())['prompts'] |
| for prompt in table: |
| k = prompt['prompt_index'] |
| - with Image.open(folder / prompt['mask']) as im: |
| - mask = np.asarray(im) |
| + if compact: |
| + mask = (sample['image_labels'] == k).astype(np.uint8) * 255 |
| + else: |
| + with Image.open(folder / prompt['mask']) as im: |
| + mask = np.asarray(im) |
| np.testing.assert_array_equal(mask != 0, sample['image_labels'] == k) |
| if set(np.unique(mask)) - {0, 255}: |
| raise ValueError('Mask PNG is not lossless binary') |
| @@ -146,9 +154,11 @@ def validate(root, *, write_card=True, workers=DEFAULT_WORKERS): |
| """Check all views with isolated CPU workers and publish one complete report.""" |
| if not isinstance(workers, int) or isinstance(workers, bool) or workers < 1: |
| raise ValueError('Validation workers must be a positive integer') |
| + selection_path = Path(root) / 'compact_training.json' |
| + selection_sha256 = sha256(selection_path) if selection_path.exists() else None |
| dataset = ViewDataset(root) |
| rows = dataset.views |
| - if len(rows) != dataset.manifest["expected_views"]: |
| + if len(dataset.manifest['views']) != dataset.manifest["expected_views"]: |
| raise ValueError("Completed manifest has the wrong capture count") |
| if len({Path(r["file"]).name for r in rows}) != len(rows): |
| raise ValueError("Sample filenames collide in a feature cache") |
| @@ -185,9 +195,38 @@ def validate(root, *, write_card=True, workers=DEFAULT_WORKERS): |
| "checks": ["artifact hashes", "RGB/depth/label alignment", "binary mask/object identity", |
| "sparse/dense occupancy equality", "shared scene GT and prompt columns", |
| "scene split separation", "unique cache filenames"]} |
| + current_selection_sha256 = sha256(selection_path) if selection_path.exists() else None |
| + if current_selection_sha256 != selection_sha256: |
| + raise ValueError('Restored view selection changed during validation') |
| + if selection_sha256 is not None: |
| + restored_counts = {split: { |
| + 'scenes': len({row['scene'] for row in rows if row['split'] == split}), |
| + 'views': sum(row['split'] == split for row in rows)} |
| + for split in sorted({row['split'] for row in rows})} |
| + report.update(scope='restored_compact_views', full_validation=len(rows) == dataset.manifest['expected_views'], |
| + source_views=dataset.manifest['expected_views'], source_counts=report['counts'], |
| + counts=restored_counts, selection_sha256=selection_sha256) |
| vd.write_json(dataset.root / "validation.json", report) |
| if not write_card: |
| return report |
| + if report.get('scope') == 'restored_compact_views': |
| + card = [f"# {dataset.manifest['dataset']} compact observations", '', |
| + f'The validator checked {images} views, {len(scenes)} scenes, and {mask_count} prompt masks.', |
| + 'The table describes restored views.', |
| + f"The original source manifest lists {report['source_views']} views.", '', |
| + '| Split | Scenes | Views |', '| --- | ---: | ---: |'] |
| + for split, counts in report['counts'].items(): |
| + card.append(f"| {split} | {counts['scenes']} | {counts['views']} |") |
| + card.extend(['', 'Sample NPZ files contain RGB, depth, visible labels, and per-object occupancy.', |
| + 'Saved calibration and object mappings remain available.', |
| + 'The samples retain hidden object surfaces and overlapping labels.', |
| + 'NPZ labels use zero-based object indices and -1 for context.', |
| + 'The default training download omits separate PNG, depth, and mesh exports.', |
| + 'The export preserves the original manifest bytes.', '', |
| + '[Source inventory](manifest.json).', |
| + '[Validation report](validation.json).', '']) |
| + (dataset.root / 'DATASET_CARD.md').write_text('\n'.join(card)) |
| + return report |
| card = [f"# {dataset.manifest['dataset']} — converted per-view dataset", "", |
| f"Schema: `{vd.SCHEMA}`. Validated **{images} captures**, **{len(scenes)} scenes**, " |
| f"and **{mask_count} binary object masks**.", "", |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,671 @@ |
| +"""Publish compact training data and explicit optional components on Hugging Face.""" |
| +import argparse |
| +from collections import Counter, defaultdict |
| +from concurrent.futures import ThreadPoolExecutor |
| +from copy import deepcopy |
| +import hashlib |
| +import json |
| +import os |
| +from pathlib import Path |
| +import subprocess |
| + |
| +from preprocess.huggingface import SCHEMA, _archive, _json, _relative, _retry |
| +from preprocess.storage import atomic_json |
| +from utils.hashing import sha256 |
| + |
| + |
| +RECIPE_SCHEMA = 'partprobe3d.reproduction.v1' |
| +COMPACT_SCHEMA = 'partprobe3d.compact-training.v1' |
| +DEFAULT_REPO = 'cubec/PartProbe3D-preprocessed' |
| +DEFAULT_DATASETS = ('3dfront', 'sage') |
| +LEGACY_PREFIX = '_deprecated/20261020' |
| +LEGACY_REVISION = 'd13e577a7e71291ed94fa40e4297f54106577fbd' |
| + |
| + |
| +def refresh_selection(root): |
| + """Identify restored views without changing the original manifest bytes.""" |
| + root = Path(root) |
| + path = root / 'manifest.json' |
| + if not path.exists(): |
| + return |
| + manifest = _json(path) |
| + rows = [row for row in manifest['views'] |
| + if all((root / row[key]).is_file() for key in ('sample', 'camera', 'scene_gt', 'object_table'))] |
| + atomic_json(root / 'compact_training.json', { |
| + 'schema': COMPACT_SCHEMA, 'source_manifest_sha256': sha256(path), |
| + 'view_ids': [row['id'] for row in rows], |
| + 'counts': dict(Counter(row['split'] for row in rows)), |
| + 'geometry_included': False, 'observations': 'RGB, depth and labels in sample NPZ files'}) |
| + |
| + |
| +def stage_observations(source, staged, *, monitor_views=16): |
| + """Index original training files for direct streaming without another dataset copy.""" |
| + source, staged = Path(source).resolve(), Path(staged).resolve() |
| + manifest = _json(source / 'manifest.json') |
| + if (not manifest.get('complete') or len(manifest['views']) != manifest['expected_views'] |
| + or monitor_views < 1): |
| + raise ValueError('A complete source and a positive monitoring count are required') |
| + original_hash = sha256(source / 'manifest.json') |
| + |
| + def scene_groups(groups): |
| + # Follow the original scene archive order to avoid random HDD seeks. |
| + scenes = {source / row['sample']: row['scene'] for row in manifest['views']} |
| + paths_by_scene, counts = defaultdict(set), Counter() |
| + for label, paths, count in groups: |
| + scene = next(scenes[path] for path in paths if path in scenes) |
| + paths_by_scene[label, scene].update(paths) |
| + counts[label, scene] += count |
| + return [(label, sorted(paths), counts[label, scene]) |
| + for (label, scene), paths in sorted(paths_by_scene.items())] |
| + staged.mkdir(parents=True, exist_ok=True) |
| + inventory_path = staged / 'stream_inventory.json' |
| + if inventory_path.exists(): |
| + saved = _json(inventory_path) |
| + if (saved.get('source_manifest_sha256') == original_hash and saved.get('monitor_views') == monitor_views |
| + and saved.get('source_root') == str(source)): |
| + decode = lambda groups: [(label, [source / _relative(path) for path in paths], count) |
| + for label, paths, count in groups] |
| + return (manifest, [source / _relative(path) for path in saved['metadata']], |
| + scene_groups(decode(saved['core'])), scene_groups(decode(saved['held_out'])), |
| + {source / _relative(path): digest for path, digest in saved['checksums'].items()}) |
| + metadata = [source / name for name in ('manifest.json', 'conversion_policy.json') if (source / name).exists()] |
| + core, held_out, checksums = [], [], {} |
| + monitor_ids = {row['id'] for row in [row for row in manifest['views'] if row['split'] != 'train'][:monitor_views]} |
| + |
| + def inspect_view(row): |
| + selected = row['split'] == 'train' or row['id'] in monitor_ids |
| + label = 'train' if row['split'] == 'train' else 'monitor' if selected else 'held-out' |
| + folder = source / _relative(row['view_directory']) |
| + marker = folder / 'complete.json' |
| + stamp = _json(marker) |
| + if stamp['row']['id'] != row['id']: |
| + raise ValueError(f'Completion record differs from the source view: {row["id"]}') |
| + paths = {source / _relative(row[key]) for key in ('sample', 'camera', 'scene_gt', 'object_table')} |
| + paths.update((folder / 'objects.json', marker)) |
| + expected = {source / row[key]: stamp['sha256'][str(Path(row[key]).relative_to(row['view_directory']))] |
| + for key in ('sample', 'camera')} |
| + expected[folder / 'objects.json'] = stamp['sha256']['objects.json'] |
| + target_marker = (source / row['scene_gt']).with_name('complete.json') |
| + if target_marker.exists(): |
| + paths.add(target_marker) |
| + target_digest = _json(target_marker).get('sha256') |
| + if isinstance(target_digest, str): |
| + expected[source / row['scene_gt']] = target_digest |
| + return selected, (label, sorted(paths), 1), expected |
| + |
| + with ThreadPoolExecutor(max_workers=16) as pool: |
| + for number, (selected, group, expected) in enumerate(pool.map(inspect_view, manifest['views']), 1): |
| + (core if selected else held_out).append(group) |
| + checksums.update(expected) |
| + if number % 5000 == 0: |
| + print(f'INDEXED {manifest["dataset"]}: {number}/{len(manifest["views"])} views', flush=True) |
| + core, held_out = scene_groups(core), scene_groups(held_out) |
| + if sha256(source / 'manifest.json') != original_hash: |
| + raise ValueError('Source manifest changed during observation indexing') |
| + encode = lambda groups: [(label, [str(path.relative_to(source)) for path in paths], count) |
| + for label, paths, count in groups] |
| + atomic_json(inventory_path, {'source_manifest_sha256': original_hash, 'source_root': str(source), |
| + 'monitor_views': monitor_views, 'metadata': [str(path.relative_to(source)) for path in metadata], |
| + 'core': encode(core), 'held_out': encode(held_out), |
| + 'checksums': {str(path.relative_to(source)): digest for path, digest in checksums.items()}}) |
| + return manifest, metadata, core, held_out, checksums |
| + |
| + |
| +def stage_shape(source, staged): |
| + """Preserve object arrays and record existing failures as explicit exclusions.""" |
| + import numpy as np |
| + from slat_multiobj_shape.storage import object_sha256, read_view_targets |
| + |
| + source, staged = Path(source).resolve(), Path(staged).resolve() |
| + original = _json(source / 'manifest.json') |
| + source_hash = sha256(source / 'manifest.json') |
| + receipt = staged / 'export.json' |
| + if receipt.exists() and _json(receipt).get('source_manifest_sha256') == source_hash: |
| + manifest = _json(staged / 'manifest.json') |
| + else: |
| + manifest = deepcopy(original) |
| + manifest.update(entries={}, target_scope='objects', phase='objects', phase_complete=True, |
| + complete=False, excluded_views=sorted(set(original.get('excluded_views', [])) | { |
| + key for key, row in original['entries'].items() if row.get('failed_objects')})) |
| + manifest['export'] = {'source_manifest_sha256': source_hash, 'scene_latents_included': False, |
| + 'object_arrays_unchanged': True} |
| + def export_view(item): |
| + key, row = item |
| + path = source / _relative(row['file']) |
| + if sha256(path) != row['sha256']: |
| + raise ValueError(f'Original shape target checksum changed: {key}') |
| + arrays = read_view_targets(path) |
| + identity = object_sha256(arrays) |
| + arrays.update(scene_coords=np.empty((0, 3), np.uint8), scene_feats=np.empty((0, 32), np.float16), |
| + scene_status=np.array('pending'), scene_seconds=np.array(0.), |
| + scene_dual_voxels=np.array(0), scene_error=np.array('')) |
| + output = staged / _relative(row['file']) |
| + output.parent.mkdir(parents=True, exist_ok=True) |
| + np.savez_compressed(output, **arrays) |
| + if object_sha256(read_view_targets(output)) != identity: |
| + raise ValueError(f'Object shape arrays changed during export: {key}') |
| + entry = {**row, 'sha256': sha256(output), 'object_sha256': identity, |
| + 'scene_status': 'pending', 'scene_latent_cells': 0, 'scene_seconds': 0.} |
| + atomic_json(output.with_suffix('.complete.json'), entry) |
| + return key, entry |
| + selected = sorted(((key, row) for key, row in original['entries'].items() |
| + if key not in manifest['excluded_views']), key=lambda item: (item[1]['scene'], item[0])) |
| + with ThreadPoolExecutor(max_workers=8) as pool: |
| + for number, (key, entry) in enumerate(pool.map(export_view, selected), 1): |
| + manifest['entries'][key] = entry |
| + if number % 5000 == 0: |
| + print(f'SHAPE {source.parent.parent.parent.name}: {number}/{len(selected)}', flush=True) |
| + if sha256(source / 'manifest.json') != source_hash: |
| + raise ValueError('Source manifest changed during shape export') |
| + atomic_json(staged / 'manifest.json', manifest) |
| + atomic_json(receipt, manifest['export']) |
| + groups, checksums = [], {} |
| + for key, row in manifest['entries'].items(): |
| + path = staged / _relative(row['file']) |
| + groups.append(('train', [path, path.with_suffix('.complete.json')], 1)) |
| + checksums[path] = row['sha256'] |
| + return manifest, [staged / 'manifest.json', receipt], groups, checksums |
| + |
| + |
| +def package(root, output, component, name, *, destination, kind, metadata, groups, |
| + details=None, checksums=None, shard_bytes=1024**3, publisher=None): |
| + """Write deterministic shards and publish them with bounded temporary storage.""" |
| + root, output = Path(root).resolve(), Path(output).resolve() |
| + folder = output / _relative(component) / name |
| + folder.mkdir(parents=True, exist_ok=True) |
| + path = folder / 'index.json' |
| + old = _json(path) if path.exists() else {} |
| + identity = {'destination': str(destination), 'artifact_kind': kind, **(details or {})} |
| + if old and any(old.get(key) != value for key, value in identity.items()): |
| + raise ValueError(f'Package source changed. Select another output: {component}/{name}') |
| + previous = {row['file']: row for row in old.get('archives', [])} |
| + index = {'schema': SCHEMA, 'name': name, 'complete': False, **identity, 'archives': []} |
| + atomic_json(path, index) |
| + |
| + def save(label, files, views): |
| + filename = label + '.tar' |
| + files = sorted(set(files)) |
| + old_record = previous.get(filename) |
| + remote_path = f'{component}/{name}/{filename}' |
| + reusable = False |
| + if old_record and publisher and publisher.matches(remote_path, old_record): |
| + records = [] |
| + for file in files: |
| + saved = file.stat() |
| + records.append((str(file.relative_to(root)), saved.st_size, saved.st_mtime_ns)) |
| + reusable = old_record.get('identity') == hashlib.sha256(json.dumps(records).encode()).hexdigest() |
| + if reusable: |
| + record = old_record |
| + else: |
| + record = _archive(folder / filename, files, root, Path(destination), old_record, checksums=checksums) |
| + record['views'] = views |
| + index['archives'].append(record) |
| + atomic_json(path, index) |
| + print(f'PACKED {remote_path}: {record["bytes"]/1e9:.3f} GB, {views} views', flush=True) |
| + if publisher: |
| + publisher.ready(remote_path, folder / filename, record) |
| + |
| + if metadata: |
| + save('metadata', metadata, 0) |
| + emitted, paths, size, views, label, number = set(), [], 0, 0, None, 0 |
| + for group_label, group_files, group_views in groups: |
| + fresh = [path for path in group_files if path not in emitted] |
| + required = sum(path.stat().st_size + 1024 for path in fresh) |
| + if paths and (label != group_label or size + required > shard_bytes): |
| + save(f'{label}-{number:05d}', paths, views) |
| + paths, size, views, number = [], 0, 0, number + 1 |
| + emitted.update(fresh) |
| + label = group_label |
| + paths.extend(fresh) |
| + size += required |
| + views += group_views |
| + if paths: |
| + save(f'{label}-{number:05d}', paths, views) |
| + if publisher: |
| + publisher.flush() |
| + index.update(complete=True, bytes=sum(row['bytes'] for row in index['archives'])) |
| + atomic_json(path, index) |
| + if publisher: |
| + publisher.small(f'{component}/{name}/index.json', path) |
| + return index |
| + |
| + |
| +class Publisher: |
| + """Verify remote SHA-256 identities before deleting local transfer shards.""" |
| + def __init__(self, repo, *, cleanup=True, workers=4): |
| + from huggingface_hub import HfApi |
| + self.repo, self.api, self.cleanup, self.workers = repo, HfApi(), cleanup, workers |
| + self.remote = {item.rfilename: item for item in self.api.dataset_info(repo, files_metadata=True).siblings} |
| + self.pending = [] |
| + |
| + def matches(self, path, record): |
| + existing = self.remote.get(path) |
| + return bool(existing and existing.size == record['bytes'] and existing.lfs |
| + and existing.lfs.sha256 == record['sha256']) |
| + |
| + def ready(self, remote_path, local_path, record): |
| + if self.matches(remote_path, record): |
| + if self.cleanup: |
| + local_path.unlink(missing_ok=True) |
| + return |
| + self.pending.append((remote_path, local_path, record)) |
| + if len(self.pending) >= 8: |
| + self.flush() |
| + |
| + def flush(self): |
| + from huggingface_hub import CommitOperationAdd |
| + if not self.pending: |
| + return |
| + batch = self.pending |
| + print(f'UPLOADING {len(batch)} archives, {sum(row[2]["bytes"] for row in batch)/1e9:.3f} GB', flush=True) |
| + _retry(lambda: self.api.create_commit(repo_id=self.repo, repo_type='dataset', |
| + operations=[CommitOperationAdd(path_in_repo=remote, path_or_fileobj=local) |
| + for remote, local, record in batch], num_threads=self.workers, |
| + commit_message='Upload compact reproduction archives')) |
| + entries = _retry(lambda: self.api.get_paths_info(self.repo, [row[0] for row in batch], repo_type='dataset')) |
| + self.remote.update({entry.path: entry for entry in entries}) |
| + # RepoFile uses path, while RepoSibling uses rfilename. Both expose size and lfs. |
| + for remote, local, record in batch: |
| + if not self.matches(remote, record): |
| + raise ValueError(f'Remote archive verification failed: {remote}') |
| + if self.cleanup: |
| + local.unlink() |
| + self.pending = [] |
| + |
| + def small(self, remote_path, local_path): |
| + _retry(lambda: self.api.upload_file(repo_id=self.repo, repo_type='dataset', |
| + path_in_repo=remote_path, path_or_fileobj=local_path, |
| + commit_message=f'Publish {remote_path}')) |
| + |
| + |
| +def download_training(repo, name, destination, revision='main', *, cleanup=True): |
| + """Restore only active training components. Optional and deprecated paths stay untouched.""" |
| + from huggingface_hub import HfApi, hf_hub_download |
| + from preprocess.huggingface import download |
| + revision = HfApi().dataset_info(repo, revision=revision).sha |
| + cache = Path(destination).resolve() / 'outputs/huggingface/reproduction' |
| + path = hf_hub_download(repo, 'training/index.json', repo_type='dataset', revision=revision, local_dir=cache) |
| + recipe = _json(path) |
| + if recipe.get('schema') != RECIPE_SCHEMA or not recipe.get('complete'): |
| + raise ValueError('The active training inventory is incomplete') |
| + names = recipe['default_datasets'] if name == 'all' else [name] |
| + restored = [] |
| + for dataset in names: |
| + if dataset not in recipe['datasets']: |
| + raise ValueError(f'Unknown training dataset: {dataset}') |
| + for component in recipe['datasets'][dataset]['required']: |
| + relative = _relative(component) |
| + if relative.parts[0] != 'training' or relative.name != dataset: |
| + raise ValueError('Default downloads must remain in the active training folder') |
| + restored.append(download(repo, dataset, destination, revision, cleanup=cleanup, |
| + bundle_root=str(relative.parent))) |
| + return restored |
| + |
| + |
| +def publish(repo, output, names, *, monitor_views=16, optional=True, shard_bytes=1024**3, workers=4): |
| + """Publish compact observations, object targets and separate optional components.""" |
| + output = Path(output).resolve() |
| + output.mkdir(parents=True, exist_ok=True) |
| + publisher = Publisher(repo, workers=workers) |
| + recipe = {'schema': RECIPE_SCHEMA, 'complete': False, 'default_datasets': list(DEFAULT_DATASETS), |
| + 'monitor_views_per_dataset': monitor_views, 'datasets': {}, 'optional': {}, |
| + 'base_git_revision': subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip()} |
| + status = output / 'status.json' |
| + atomic_json(status, {'phase': 'running', 'repo': repo, 'pid': os.getpid()}) |
| + for name in names: |
| + source = Path('datasets') / name / 'extent/point_cloud' |
| + staged = output / 'staging' / name / 'extent/point_cloud' |
| + manifest, metadata, core, held_out, checksums = stage_observations(source, staged, monitor_views=monitor_views) |
| + digest = sha256(source / 'manifest.json') |
| + destination = Path('datasets') / name / 'extent/point_cloud' |
| + details = {'source_manifest_sha256': digest, 'resolution': manifest['resolution'], |
| + 'source_views': len(manifest['views']), 'views': sum(row[2] for row in core), |
| + 'monitor_views': sum(row[2] for row in core if row[0] == 'monitor'), |
| + 'training_views': sum(row[2] for row in core if row[0] == 'train')} |
| + index = package(source, output, 'training/observations', name, destination=destination, |
| + kind='compact-training', metadata=metadata, groups=core, details=details, |
| + checksums=checksums, shard_bytes=shard_bytes, publisher=publisher) |
| + record = {'required': [f'training/observations/{name}'], 'bytes': index['bytes'], **details} |
| + shape = Path('datasets') / name / 'slat/32/targets' |
| + if (shape / 'manifest.json').exists(): |
| + shape_stage = output / 'staging' / name / 'slat/32/targets' |
| + targets, shape_metadata, groups, target_checksums = stage_shape(shape, shape_stage) |
| + shape_index = package(shape_stage, output, 'training/shape/32', name, |
| + destination=Path('datasets') / name / 'slat/32/targets', kind='object-shape-targets', |
| + metadata=shape_metadata, groups=groups, checksums=target_checksums, |
| + details={'source_manifest_sha256': sha256(shape / 'manifest.json'), 'resolution': 32, |
| + 'views': len(targets['entries']), 'excluded_views': targets['excluded_views'], |
| + 'dataset_manifest_sha256': digest, 'scene_latents_included': False}, |
| + shard_bytes=shard_bytes, publisher=publisher) |
| + record['required'].append(f'training/shape/32/{name}') |
| + record['bytes'] += shape_index['bytes'] |
| + record['shape_excluded_views'] = targets['excluded_views'] |
| + recipe['datasets'][name] = record |
| + if optional: |
| + if held_out: |
| + held_index = package(source, output, 'optional/held_out', name, destination=destination, |
| + kind='held-out-observations', metadata=[], groups=held_out, checksums=checksums, |
| + details={'source_manifest_sha256': digest, 'views': sum(row[2] for row in held_out)}, |
| + shard_bytes=shard_bytes, publisher=publisher) |
| + recipe['optional'][f'held_out/{name}'] = {'component': f'optional/held_out/{name}', |
| + 'bytes': held_index['bytes']} |
| + geometry = sorted({source.resolve() / row['geometry'] for row in manifest['views']}) |
| + if geometry and all(path.exists() for path in geometry): |
| + from dataloader.geometry import geometry_artifacts |
| + groups = [('geometry', geometry_artifacts(source, str(path.relative_to(source.resolve()))), 0) |
| + for path in geometry] |
| + geometry_index = package(source, output, 'optional/geometry', name, destination=destination, |
| + kind='mesh-geometry', metadata=[], groups=groups, |
| + details={'source_manifest_sha256': digest}, shard_bytes=shard_bytes, publisher=publisher) |
| + recipe['optional'][f'geometry/{name}'] = {'component': f'optional/geometry/{name}', |
| + 'bytes': geometry_index['bytes']} |
| + atomic_json(output / 'training/index.json', recipe) |
| + atomic_json(status, {'phase': 'running', 'repo': repo, 'pid': os.getpid(), 'finished_dataset': name, |
| + 'datasets': list(recipe['datasets'])}) |
| + recipe['complete'] = True |
| + atomic_json(output / 'training/index.json', recipe) |
| + publisher.small('training/index.json', output / 'training/index.json') |
| + atomic_json(status, {'phase': 'data_uploaded', 'repo': repo, 'pid': os.getpid(), |
| + 'revision': publisher.api.dataset_info(repo).sha, 'datasets': recipe['datasets']}) |
| + return recipe |
| + |
| + |
| +def publish_evaluation(repo, output): |
| + """Publish YCB-V scoring inputs without duplicate image and depth files.""" |
| + from dataloader.geometry import geometry_artifacts |
| + output = Path(output).resolve() |
| + source = Path('datasets/ycbv/extent/point_cloud') |
| + ready = output / 'optional/evaluation/ycbv/index.json' |
| + if ready.exists(): |
| + previous = _json(ready) |
| + if previous.get('complete') and previous.get('source_manifest_sha256') == sha256(source / 'manifest.json'): |
| + remote = Publisher(repo) |
| + if all(remote.matches(f'optional/evaluation/ycbv/{row["file"]}', row) for row in previous['archives']): |
| + return {'component': 'optional/evaluation/ycbv', 'bytes': previous['bytes']} |
| + staged = output / 'staging/ycbv/extent/point_cloud' |
| + manifest, metadata, groups, _, checksums = stage_observations(source, staged, monitor_views=1000000) |
| + for relative in sorted({row['geometry'] for row in manifest['views']}): |
| + files = geometry_artifacts(source, relative) |
| + groups.append(('geometry', files, 0)) |
| + index = package(source, output, 'optional/evaluation', 'ycbv', |
| + destination=Path('datasets/ycbv/extent/point_cloud'), kind='compact-training', metadata=metadata, |
| + groups=groups, checksums=checksums, details={'source_manifest_sha256': sha256(source / 'manifest.json'), |
| + 'evaluation_only': True, 'views': len(manifest['views']), 'geometry_included': True}, |
| + publisher=Publisher(repo)) |
| + return {'component': 'optional/evaluation/ycbv', 'bytes': index['bytes']} |
| + |
| + |
| +def _copy_files(api, repo, output, mapping, *, revision=LEGACY_REVISION, remove_sources=False): |
| + """Copy LFS objects on the server and transfer only small Git files.""" |
| + from huggingface_hub import CommitOperationAdd, CommitOperationCopy, CommitOperationDelete, hf_hub_download |
| + source_info = api.dataset_info(repo, revision=revision, files_metadata=True) |
| + sources = {row.rfilename: row for row in source_info.siblings} |
| + current = {row.rfilename: row for row in api.dataset_info(repo, files_metadata=True).siblings} |
| + operations = [] |
| + commits = [] |
| + |
| + def flush(): |
| + if operations: |
| + result = _retry(lambda: api.create_commit(repo_id=repo, repo_type='dataset', operations=list(operations), |
| + commit_message='Move superseded dataset uploads to the deprecated folder' if remove_sources |
| + else 'Separate optional GT occlusion archives')) |
| + commits.append(result.oid) |
| + operations.clear() |
| + |
| + for source, target in mapping.items(): |
| + original = sources[source] |
| + existing = current.get(target) |
| + matches = bool(existing and existing.size == original.size and ( |
| + existing.lfs.sha256 == original.lfs.sha256 if original.lfs and existing.lfs |
| + else existing.blob_id == original.blob_id)) |
| + if existing and not matches: |
| + raise ValueError(f'Existing destination differs from the historical file: {target}') |
| + if not matches: |
| + if original.lfs: |
| + operations.append(CommitOperationCopy(src_path_in_repo=source, path_in_repo=target, |
| + src_revision=revision)) |
| + else: |
| + local = hf_hub_download(repo, source, repo_type='dataset', revision=revision, |
| + local_dir=Path(output) / 'historical_metadata') |
| + operations.append(CommitOperationAdd(path_in_repo=target, path_or_fileobj=local)) |
| + if remove_sources and source in current: |
| + old = current[source] |
| + same = old.lfs.sha256 == original.lfs.sha256 if old.lfs and original.lfs else old.blob_id == original.blob_id |
| + if not same: |
| + raise ValueError(f'The legacy source changed during migration: {source}') |
| + operations.append(CommitOperationDelete(path_in_repo=source)) |
| + if len(operations) >= 100: |
| + flush() |
| + flush() |
| + return commits |
| + |
| + |
| +def export_code(output, base_revision): |
| + """Export only this migration's source changes, preserving unrelated workspace edits.""" |
| + output = Path(output) |
| + folder = output / 'code' |
| + folder.mkdir(parents=True, exist_ok=True) |
| + tracked = ['HF_DATASETS.md', 'preprocess/slat/HUGGING_FACE.md', 'preprocess/slat/README.md', 'dataloader/dataset.py', |
| + 'dataloader/extent.py', 'preprocess/huggingface.py', 'preprocess/validate_dataset.py'] |
| + added = ['preprocess/reproduction.py', 'preprocess/tests/test_reproduction.py'] |
| + content = subprocess.check_output(['git', 'diff', '--binary', base_revision, '--', *tracked, *added]) |
| + for path in added: |
| + present = subprocess.run(['git', 'cat-file', '-e', f'{base_revision}:{path}'], |
| + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0 |
| + indexed = subprocess.run(['git', 'ls-files', '--error-unmatch', path], |
| + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL).returncode == 0 |
| + if present or indexed: |
| + continue |
| + result = subprocess.run(['git', 'diff', '--binary', '--no-index', '--', '/dev/null', path], |
| + stdout=subprocess.PIPE, check=False) |
| + if result.returncode not in (0, 1): |
| + raise RuntimeError(f'Cannot export restore source: {path}') |
| + content += result.stdout |
| + patch = folder / 'reproduction.patch' |
| + patch.write_bytes(content) |
| + manifest = {'base_git_revision': base_revision, 'patch_sha256': sha256(patch), |
| + 'files': {path: sha256(path) for path in [*tracked, *added]}} |
| + atomic_json(folder / 'manifest.json', manifest) |
| + return manifest |
| + |
| + |
| +def write_card(output, recipe, repo): |
| + """Write the active download instructions with measured archive sizes.""" |
| + output = Path(output) |
| + total = sum(recipe['datasets'][name]['bytes'] for name in recipe['default_datasets']) |
| + lines = ['---', 'language:', '- en', 'tags:', '- 3d', '- depth', '- segmentation', |
| + '- voxel-occupancy', 'pretty_name: PartProbe3D compact reproduction data', '---', '', |
| + '# PartProbe3D reproduction data', '', |
| + 'This release supports SS, generative SLAT segmentation, and 32³ SLAT shape training.', |
| + f'The default transfer is **{total/1e9:.2f} GB**, including both training datasets and object shape targets.', |
| + 'Default downloads exclude optional and deprecated folders.', '', |
| + '## Restore tools', '', |
| + f'Use the project checkout at Git revision `{recipe["base_git_revision"]}`.', |
| + 'Apply the supplied restore patch before using the compact data.', |
| + 'The patch preserves unrelated files and adds the compact readers and download commands.', '', |
| + '```bash', f'hf download {repo} code/reproduction.patch --repo-type dataset --local-dir outputs/huggingface/bootstrap', |
| + 'git apply --check outputs/huggingface/bootstrap/code/reproduction.patch', |
| + 'git apply outputs/huggingface/bootstrap/code/reproduction.patch', |
| + "python -m pip install -e '.[preprocess,ss-multiobj-depth,slat-segvigen,slat-multiobj-shape]'", '```', '', |
| + 'The [source manifest](code/manifest.json) records the patch checksum and required Git revision.', '', |
| + '## Default download', '', 'Run this command from the patched project root:', '', '```bash', |
| + f'python -m preprocess.huggingface download --repo {repo}', '```', '', |
| + 'The command restores 3D-FRONT, SAGE-10k, and their 32³ object shape targets.', |
| + 'It verifies each archive and removes temporary archives after restoration.', |
| + 'The downloader pins one Hub revision before reading any archive.', |
| + 'Add `--revision <Hub commit>` to select a fixed release.', |
| + 'Add `--keep-archives` only when you need temporary transfer files.', '', |
| + '| Dataset | SS/segmentation training views | Shape training views | Monitoring views | Transfer, GB |', |
| + '| --- | ---: | ---: | ---: | ---: |'] |
| + for name, row in recipe['datasets'].items(): |
| + shape_views = row['training_views'] - len(row.get('shape_excluded_views', [])) if len(row['required']) > 1 else 'Unavailable' |
| + lines.append(f'| {name} | {row["training_views"]:,} | {shape_views if isinstance(shape_views, str) else format(shape_views, ",")} | {row["monitor_views"]} | {row["bytes"]/1e9:.2f} |') |
| + lines += ['', 'FoundationPose requires explicit selection and supports SS and segmentation.', '', '```bash', |
| + f'python -m preprocess.huggingface download --repo {repo} --dataset foundationpose', '```', '', |
| + '## Contents', '', |
| + 'Sample NPZ files retain RGB, metric depth, visible labels, complete object occupancy, and the original transforms.', |
| + 'Calibration, scene voxel targets, object mappings, and original extent manifests remain available.', |
| + 'The compact export omits separate RGB, masks, depth copies, overlays, and duplicate voxel exports.', |
| + 'Every training view remains available to SS and segmentation.', |
| + 'The first 16 test views per dataset support existing eight-view and sixteen-view training monitors.', |
| + 'All other test observations require an optional download.', '', |
| + 'Object shape arrays retain their original values and identities.', |
| + 'Shape manifests explicitly exclude the three failed SAGE views used by the existing experiment.', |
| + 'SS and segmentation retain those views.', |
| + 'The export omits combined scene latents because the current shape objective uses object targets.', |
| + 'Model weights and image-feature caches remain separate dependencies.', '', |
| + '## Optional components', '', |
| + '| Component | Purpose | Transfer, GB |', '| --- | --- | ---: |'] |
| + descriptions = {'geometry': 'Mesh scoring and new target encoding', 'held_out': 'Remaining test observations', |
| + 'occlusion': 'GT relations for SS object attention', 'evaluation': 'YCB-V mesh evaluation'} |
| + for name, row in sorted(recipe['optional'].items()): |
| + lines.append(f'| `{name}` | {descriptions[name.split("/")[0]]} | {row["bytes"]/1e9:.3f} |') |
| + lines += ['', 'Restore observations before geometry, occlusion, or test overlays.', |
| + 'YCB-V evaluation includes its own observations and geometry.', 'Select each optional component explicitly:', '', |
| + '```bash', f'python -m preprocess.huggingface download --repo {repo} --dataset sage --optional geometry', |
| + f'python -m preprocess.huggingface download --repo {repo} --dataset 3dfront --optional occlusion', |
| + f'python -m preprocess.huggingface download --repo {repo} --dataset sage --optional held-out', |
| + f'python -m preprocess.huggingface download --repo {repo} --dataset ycbv --optional evaluation', '```', '', |
| + '## Train all three stages', '', |
| + 'Obtain the configured model weights separately.', 'Run SS preparation before SS training.', '', |
| + '```bash', 'export CUDA_VISIBLE_DEVICES=4,6', 'export CUDA_DEVICE_ORDER=PCI_BUS_ID', |
| + 'python -m ss_multiobj_depth.prepare --config ss_multiobj_depth/configs/front3d_sage.json', |
| + 'python -m ss_multiobj_depth.train --config ss_multiobj_depth/configs/front3d_sage.json', |
| + 'python -m slat_segvigen.train --config slat_segvigen/configs/object_mean_image_nora_coverage_gate.json', |
| + 'python -m preprocess.slat.prepare --config preprocess/slat/configs/front3d_sage_32_assigned_object.json --stage features --devices cuda:0 cuda:1', |
| + 'python -m slat_multiobj_shape.train --config slat_multiobj_shape/configs/front3d_sage_32_assigned_object.json', '```', '', |
| + 'Use the saved configuration and pretrained assets for a specific experiment.', |
| + 'Feature preparation creates local caches without meshes or another dataset download.', |
| + 'For lower local storage, generate an online shape configuration:', '', '```bash', |
| + 'python -m preprocess.reproduction configure-shape --output outputs/reproduction/shape_online.json', |
| + 'python -m slat_multiobj_shape.train --config outputs/reproduction/shape_online.json', '```', '', |
| + 'The generated configuration computes image conditioning during training and avoids separate image-feature caches.', |
| + 'It preserves the selected preset\'s model and optimization settings.', |
| + 'Use the original cached preset when reproducing a cached-feature experiment.', |
| + 'Data and decoder provenance remain in the restored manifests.', |
| + 'Exact checkpoint resume requires the original matching feature and data identities.', '', |
| + '## Deprecated uploads', '', |
| + f'`{LEGACY_PREFIX}/` contains superseded bundles and catalogs.', |
| + 'The project downloader never selects these paths.', |
| + 'An unfiltered Hugging Face snapshot download includes every folder.', |
| + 'Use the project downloader for minimal transfer.', |
| + f'The [original release](https://huggingface.co/datasets/{repo}/tree/{LEGACY_REVISION}) remains available by revision.', '', |
| + '## Source terms and previews', '', |
| + 'Source dataset terms continue to apply to these derived observations.', |
| + 'The prepared data does not replace access agreements for original source assets.', '', |
| + '', '', |
| + '', '', |
| + '[Posed object geometry](previews/3dfront/train-geometry.glb)', ''] |
| + (output / 'README.md').write_text('\n'.join(lines)) |
| + |
| + |
| +def finalize(repo, output, *, deprecate=False): |
| + """Verify active artifacts before moving any legacy file.""" |
| + from huggingface_hub import HfApi, hf_hub_download |
| + output = Path(output).resolve() |
| + recipe = _json(output / 'training/index.json') |
| + if not recipe.get('complete'): |
| + raise ValueError('Complete training publication before finalizing the repository') |
| + api = HfApi() |
| + legacy = api.dataset_info(repo, revision=LEGACY_REVISION, files_metadata=True) |
| + copies = {row.rfilename: row.rfilename.replace('precomputed_occlusion/', 'optional/occlusion/', 1) |
| + for row in legacy.siblings if row.rfilename.startswith('precomputed_occlusion/') |
| + and (row.rfilename.endswith('.tar') or row.rfilename.endswith('/index.json'))} |
| + _copy_files(api, repo, output, copies) |
| + for name in DEFAULT_DATASETS: |
| + path = hf_hub_download(repo, f'precomputed_occlusion/{name}/index.json', repo_type='dataset', |
| + revision=LEGACY_REVISION, local_dir=output / 'historical_metadata') |
| + recipe['optional'][f'occlusion/{name}'] = {'component': f'optional/occlusion/{name}', 'bytes': _json(path)['bytes']} |
| + recipe['optional']['evaluation/ycbv'] = publish_evaluation(repo, output) |
| + publisher = Publisher(repo) |
| + components = [part for row in recipe['datasets'].values() for part in row['required']] |
| + components += [row['component'] for row in recipe['optional'].values()] |
| + verified = [] |
| + for component in components: |
| + path = hf_hub_download(repo, f'{component}/index.json', repo_type='dataset', local_dir=output / 'verification') |
| + index = _json(path) |
| + if not index.get('complete'): |
| + raise ValueError(f'Incomplete component: {component}') |
| + for row in index['archives']: |
| + if not publisher.matches(f'{component}/{row["file"]}', row): |
| + raise ValueError(f'Remote archive mismatch: {component}/{row["file"]}') |
| + verified.append({'component': component, 'archives': len(index['archives']), 'bytes': index['bytes']}) |
| + code = export_code(output, recipe['base_git_revision']) |
| + publisher.small('code/reproduction.patch', output / 'code/reproduction.patch') |
| + publisher.small('code/manifest.json', output / 'code/manifest.json') |
| + atomic_json(output / 'training/index.json', recipe) |
| + publisher.small('training/index.json', output / 'training/index.json') |
| + write_card(output, recipe, repo) |
| + publisher.small('README.md', output / 'README.md') |
| + commits = [] |
| + if deprecate: |
| + prefixes = ('bundles/', 'precomputed_slat/', 'precomputed_occlusion/', 'metadata/', 'catalog/') |
| + mapping = {row.rfilename: f'{LEGACY_PREFIX}/{row.rfilename}' for row in legacy.siblings |
| + if row.rfilename.startswith(prefixes) or row.rfilename == 'catalog.json'} |
| + commits = _copy_files(api, repo, output, mapping, remove_sources=True) |
| + folder = output / LEGACY_PREFIX |
| + folder.mkdir(parents=True, exist_ok=True) |
| + (folder / 'README.md').write_text('# Deprecated dataset uploads\n\n' |
| + 'These files preserve the previous dataset layout.\n' |
| + 'Default reproduction downloads exclude this folder.\n' |
| + 'Use the active `training/` components and explicit `optional/` downloads.\n\n' |
| + f'[Original release](https://huggingface.co/datasets/{repo}/tree/{LEGACY_REVISION}).\n') |
| + publisher.small(f'{LEGACY_PREFIX}/README.md', folder / 'README.md') |
| + result = {'complete': True, 'repo': repo, 'revision': api.dataset_info(repo).sha, |
| + 'components': verified, 'code': code, 'deprecation_commits': commits, |
| + 'default_bytes': sum(recipe['datasets'][name]['bytes'] for name in recipe['default_datasets'])} |
| + atomic_json(output / 'completion.json', result) |
| + atomic_json(output / 'status.json', {'phase': 'complete', **result}) |
| + return result |
| + |
| + |
| +def configure_shape(source, output): |
| + """Select online image conditioning without changing model or optimization settings.""" |
| + config = _json(source) |
| + for entry in config.get('prepared_datasets', []): |
| + entry.pop('features', None) |
| + entry.pop('training_targets', None) |
| + config.pop('features', None) |
| + config.pop('training_targets', None) |
| + config['output'] = 'outputs/slat_multiobj_shape/reproduction_online/train' |
| + config['checkpoints'] = 'checkpoints/training/slat_multiobj_shape/reproduction_online' |
| + config['checkpoint'] = config['checkpoints'] + '/last.pt' |
| + output = Path(output) |
| + output.parent.mkdir(parents=True, exist_ok=True) |
| + if output.exists() and _json(output) != config: |
| + raise FileExistsError(f'Configuration already contains different settings: {output}') |
| + atomic_json(output, config) |
| + return config |
| + |
| + |
| +def main(): |
| + parser = argparse.ArgumentParser(description=__doc__) |
| + commands = parser.add_subparsers(dest='command', required=True) |
| + publishing = commands.add_parser('publish') |
| + publishing.add_argument('--repo', default=DEFAULT_REPO) |
| + publishing.add_argument('--output', type=Path, required=True) |
| + publishing.add_argument('--dataset', action='append', required=True) |
| + publishing.add_argument('--monitor-views', type=int, default=16) |
| + publishing.add_argument('--workers', type=int, default=4) |
| + publishing.add_argument('--shard-gib', type=float, default=1) |
| + publishing.add_argument('--without-optional', action='store_true') |
| + finishing = commands.add_parser('finalize') |
| + finishing.add_argument('--repo', default=DEFAULT_REPO) |
| + finishing.add_argument('--output', type=Path, required=True) |
| + finishing.add_argument('--deprecate', action='store_true') |
| + configuring = commands.add_parser('configure-shape') |
| + configuring.add_argument('--source', type=Path, |
| + default=Path('slat_multiobj_shape/configs/front3d_sage_32_assigned_object.json')) |
| + configuring.add_argument('--output', type=Path, required=True) |
| + args = parser.parse_args() |
| + if args.command == 'finalize': |
| + finalize(args.repo, args.output, deprecate=args.deprecate) |
| + elif args.command == 'configure-shape': |
| + configure_shape(args.source, args.output) |
| + else: |
| + publish(args.repo, args.output, args.dataset, monitor_views=args.monitor_views, |
| + optional=not args.without_optional, shard_bytes=int(args.shard_gib * 1024**3), workers=args.workers) |
| + |
| + |
| +if __name__ == '__main__': |
| + main() |
| |
| new file mode 100644 |
| |
| |
| |
| @@ -0,0 +1,222 @@ |
| +"""Compact exports retain training tensors and never select deprecated downloads.""" |
| +import json |
| +from pathlib import Path |
| +from types import SimpleNamespace |
| + |
| +import numpy as np |
| +import pytest |
| + |
| +from dataloader.dataset import ViewDataset |
| +from dataloader.extent import ExtentLoader |
| +from dataloader.prepared import ExtentDataset |
| +from preprocess.huggingface import extract |
| +from preprocess.reproduction import (COMPACT_SCHEMA, RECIPE_SCHEMA, download_training, package, |
| + refresh_selection, stage_observations, stage_shape) |
| +from preprocess.storage import atomic_json |
| +from preprocess.tests.test_validate_dataset import dataset |
| +from utils.hashing import sha256 |
| + |
| + |
| +def test_compact_restore_preserves_tensors_and_adds_optional_test_views(dataset, tmp_path): |
| + source, original = dataset |
| + staged = tmp_path / 'staged' |
| + manifest, metadata, core, held_out, checksums = stage_observations(source, staged, monitor_views=1) |
| + output = tmp_path / 'archives' |
| + destination = Path('datasets/fixture/extent/point_cloud') |
| + index = package(source, output, 'training/observations', 'fixture', destination=destination, |
| + kind='compact-training', metadata=metadata, groups=core, checksums=checksums) |
| + restored = extract(index, output / 'training/observations/fixture', tmp_path / 'server') |
| + assert sha256(restored / 'manifest.json') == sha256(source / 'manifest.json') |
| + assert len(ViewDataset(restored)) == 3 |
| + assert not list(restored.rglob('*.png')) |
| + assert not list(restored.rglob('depth.npy')) |
| + assert not list(restored.rglob('geometry.npz')) |
| + expected = ExtentDataset(source, split='train') |
| + actual = ExtentDataset(restored, split='train') |
| + assert len(expected) == len(actual) == 2 |
| + import torch |
| + for a, b in zip(expected, actual): |
| + for key in ('rgb', 'masks', 'depth', 'memberships', 'coords', 'intrinsics', 'model_to_world'): |
| + torch.testing.assert_close(a[key], b[key], rtol=0, atol=0) |
| + loader = ExtentLoader(restored) |
| + rgb, masks = loader.load_observation(0) |
| + arrays = ViewDataset(restored)[0] |
| + np.testing.assert_array_equal(rgb, arrays['rgb']) |
| + np.testing.assert_array_equal(masks, arrays['image_labels'] + 1) |
| + from preprocess.validate_dataset import validate |
| + report = validate(restored, workers=1) |
| + assert report['validated_views'] == 3 |
| + assert report['counts']['train']['views'] == 2 and report['counts']['test']['views'] == 1 |
| + assert report['source_counts'] == original['counts'] |
| + assert report['selection_sha256'] == sha256(restored / 'compact_training.json') |
| + assert '| test | 1 | 1 |' in (restored / 'DATASET_CARD.md').read_text() |
| + optional = package(source, output, 'optional/held_out', 'fixture', destination=destination, |
| + kind='held-out-observations', metadata=[], groups=held_out, checksums=checksums) |
| + extract(optional, output / 'optional/held_out/fixture', tmp_path / 'server') |
| + assert len(ViewDataset(restored)) == 4 |
| + # Repeating the compact restore must preserve separately restored test views. |
| + extract(index, output / 'training/observations/fixture', tmp_path / 'server') |
| + assert len(ViewDataset(restored)) == 4 |
| + |
| + |
| +def test_compact_pack_rejects_corrupt_original_sample(dataset, tmp_path): |
| + source, _ = dataset |
| + _, metadata, groups, _, checksums = stage_observations(source, tmp_path / 'staged', monitor_views=1) |
| + row = json.loads((source / 'manifest.json').read_text())['views'][0] |
| + (source / row['sample']).write_bytes(b'corrupt source') |
| + with pytest.raises(ValueError, match='Source checksum changed'): |
| + package(source, tmp_path / 'archives', 'training/observations', 'fixture', |
| + destination=Path('datasets/fixture/extent/point_cloud'), kind='compact-training', |
| + metadata=metadata, groups=groups, checksums=checksums) |
| + |
| + |
| +def test_compact_validation_rejects_changed_view_selection(dataset, monkeypatch): |
| + from preprocess import validate_dataset |
| + root, _ = dataset |
| + refresh_selection(root) |
| + path = root / 'compact_training.json' |
| + selection = json.loads(path.read_text()) |
| + selection['view_ids'] = selection['view_ids'][:-1] |
| + selection['counts'] = {'train': 2, 'test': 1} |
| + atomic_json(path, selection) |
| + original = validate_dataset._validate_view |
| + def changed(root, row): |
| + result = original(root, row) |
| + refresh_selection(root) |
| + return result |
| + monkeypatch.setattr(validate_dataset, '_validate_view', changed) |
| + with pytest.raises(ValueError, match='selection changed during validation'): |
| + validate_dataset.validate(root, workers=1) |
| + assert not (root / 'validation.json').exists() |
| + |
| + |
| +def test_object_shape_export_retains_object_identity_and_explicit_exclusions(tmp_path): |
| + from slat_multiobj_shape.storage import SCHEMA, object_sha256, read_view_targets |
| + root = tmp_path / 'source' |
| + file = root / 'views/fixture/good.npz' |
| + file.parent.mkdir(parents=True) |
| + arrays = dict(schema=np.array(SCHEMA), coords=np.array([[1, 2, 3]], np.uint8), |
| + feats=np.ones((1, 32), np.float16), object_index=np.zeros(1, np.int16), |
| + object_ids=np.array(['object']), object_status=np.array(['complete']), |
| + resolution=np.array(32), model_to_world=np.eye(4), grid_size=np.array(512), |
| + scene_coords=np.array([[1, 2, 3]], np.uint8), scene_feats=np.ones((1, 32), np.float16), |
| + scene_status=np.array('complete'), scene_scope=np.array('selected_prompt_objects'), |
| + scene_seconds=np.array(1.), scene_dual_voxels=np.array(1), scene_error=np.array('')) |
| + np.savez_compressed(file, **arrays) |
| + row = {'file': 'views/fixture/good.npz', 'split': 'train', 'scene': 'room', |
| + 'failed_objects': 0, 'sha256': sha256(file)} |
| + atomic_json(root / 'manifest.json', {'schema': SCHEMA, 'resolution': 32, |
| + 'entries': {'fixture/good': row, 'fixture/bad': {**row, 'failed_objects': 1}}, |
| + 'datasets': [], 'models': {}, 'complete': False}) |
| + manifest, _, groups, _ = stage_shape(root, tmp_path / 'staged') |
| + assert manifest['excluded_views'] == ['fixture/bad'] |
| + assert len(groups) == 1 |
| + exported = read_view_targets(tmp_path / 'staged' / row['file']) |
| + assert object_sha256(exported) == object_sha256(arrays) |
| + assert not len(exported['scene_feats']) and str(exported['scene_status']) == 'pending' |
| + assert len(read_view_targets(file)['scene_feats']) == 1 |
| + |
| + |
| +def test_default_download_pins_recipe_and_excludes_optional_and_deprecated(tmp_path, monkeypatch): |
| + import huggingface_hub |
| + import preprocess.huggingface |
| + revision = 'a' * 40 |
| + recipe = tmp_path / 'index.json' |
| + atomic_json(recipe, {'schema': RECIPE_SCHEMA, 'complete': True, 'default_datasets': ['fixture'], |
| + 'datasets': {'fixture': {'required': ['training/observations/fixture', 'training/shape/32/fixture']}}, |
| + 'optional': {'geometry': '_deprecated/old'}}) |
| + monkeypatch.setattr(huggingface_hub, 'HfApi', lambda: SimpleNamespace( |
| + dataset_info=lambda *a, **k: SimpleNamespace(sha=revision))) |
| + monkeypatch.setattr(huggingface_hub, 'hf_hub_download', lambda *a, **k: str(recipe)) |
| + calls = [] |
| + monkeypatch.setattr(preprocess.huggingface, 'download', lambda *a, **k: calls.append((a, k))) |
| + download_training('owner/repo', 'all', tmp_path / 'server') |
| + assert [call[1]['bundle_root'] for call in calls] == ['training/observations', 'training/shape/32'] |
| + assert all(call[0][3] == revision and call[1]['cleanup'] for call in calls) |
| + data = json.loads(recipe.read_text()) |
| + data['datasets']['fixture']['required'].append('_deprecated/fixture') |
| + atomic_json(recipe, data) |
| + with pytest.raises(ValueError, match='active training folder'): |
| + download_training('owner/repo', 'all', tmp_path / 'server') |
| + |
| + |
| +def test_compact_selection_rejects_another_manifest(dataset): |
| + root, _ = dataset |
| + atomic_json(root / 'compact_training.json', {'schema': COMPACT_SCHEMA, |
| + 'source_manifest_sha256': 'wrong', 'view_ids': []}) |
| + with pytest.raises(ValueError, match='source manifest'): |
| + ViewDataset(root) |
| + |
| + |
| +@pytest.mark.parametrize('corrupt', [False, True]) |
| +def test_upload_cleanup_requires_verified_remote_digest(tmp_path, monkeypatch, corrupt): |
| + import huggingface_hub |
| + from preprocess.reproduction import Publisher |
| + path = tmp_path / 'archive.tar' |
| + path.write_bytes(b'verified data') |
| + digest = sha256(path) |
| + entry = SimpleNamespace(path='training/observations/fixture/train.tar', size=path.stat().st_size, |
| + lfs=SimpleNamespace(sha256='wrong' if corrupt else digest)) |
| + api = SimpleNamespace(dataset_info=lambda *a, **k: SimpleNamespace(siblings=[]), |
| + create_commit=lambda **k: SimpleNamespace(oid='commit'), |
| + get_paths_info=lambda *a, **k: [entry]) |
| + monkeypatch.setattr(huggingface_hub, 'HfApi', lambda: api) |
| + publisher = Publisher('owner/repo') |
| + publisher.ready(entry.path, path, {'bytes': path.stat().st_size, 'sha256': digest}) |
| + if corrupt: |
| + with pytest.raises(ValueError, match='verification failed'): |
| + publisher.flush() |
| + assert path.read_bytes() == b'verified data' |
| + else: |
| + publisher.flush() |
| + assert not path.exists() |
| + |
| + |
| +def test_deprecation_rejects_concurrently_changed_legacy_file(tmp_path): |
| + from preprocess.reproduction import _copy_files, LEGACY_REVISION |
| + old = SimpleNamespace(rfilename='bundles/fixture/train.tar', size=10, blob_id='blob', |
| + lfs=SimpleNamespace(sha256='original')) |
| + changed = SimpleNamespace(rfilename=old.rfilename, size=10, blob_id='changed', |
| + lfs=SimpleNamespace(sha256='changed')) |
| + def info(*args, **kwargs): |
| + return SimpleNamespace(siblings=[old if kwargs.get('revision') == LEGACY_REVISION else changed]) |
| + api = SimpleNamespace(dataset_info=info, create_commit=lambda **k: pytest.fail('Changed data must remain untouched')) |
| + with pytest.raises(ValueError, match='source changed'): |
| + _copy_files(api, 'owner/repo', tmp_path, |
| + {old.rfilename: '_deprecated/old/' + old.rfilename}, remove_sources=True) |
| + |
| + |
| +@pytest.mark.parametrize('optional,keep', [(False, False), (True, False), (False, True)]) |
| +def test_download_command_defaults_to_active_data_and_removes_archives(monkeypatch, optional, keep): |
| + import sys |
| + from preprocess import huggingface |
| + arguments = ['download', '--repo', 'owner/repo'] |
| + if optional: |
| + arguments += ['--dataset', 'fixture', '--optional', 'geometry'] |
| + if keep: |
| + arguments += ['--keep-archives'] |
| + monkeypatch.setattr(sys, 'argv', ['huggingface', *arguments]) |
| + calls = [] |
| + monkeypatch.setattr(huggingface, 'download', lambda *a, **k: calls.append((a, k))) |
| + huggingface.main() |
| + assert calls[0][1]['cleanup'] is not keep |
| + assert calls[0][1]['bundle_root'] == ('optional/geometry' if optional else None) |
| + assert calls[0][0][1] == ('fixture' if optional else 'all') |
| + |
| + |
| +def test_online_shape_configuration_preserves_model_and_optimizer_settings(tmp_path): |
| + from preprocess.reproduction import configure_shape |
| + original = {'model': {'rank': 8, 'local_condition_mode': 'assigned_object'}, |
| + 'training': {'learning_rate': .0001, 'optimizer': {'betas': [.9, .95]}}, |
| + 'prepared_datasets': [{'targets': 'datasets/fixture/slat/32/targets', |
| + 'features': 'old', 'training_targets': 'old'}], |
| + 'require_scene_targets': False, 'features': 'old', 'training_targets': 'old'} |
| + source = tmp_path / 'source.json' |
| + atomic_json(source, original) |
| + output = tmp_path / 'generated/online.json' |
| + actual = configure_shape(source, output) |
| + assert actual['model'] == original['model'] and actual['training'] == original['training'] |
| + assert actual['prepared_datasets'] == [{'targets': 'datasets/fixture/slat/32/targets'}] |
| + assert not {'features', 'training_targets'} & actual.keys() |
| + assert json.loads(source.read_text()) == original |
| + assert configure_shape(source, output) == actual |
|
|
