---
license: other
license_name: release-license-pending
license_link: LICENSE.md
tags:
- pointzero
- 3d
- robotics
- point-tracking
- synthetic
- webdataset
pretty_name: PointZero Sparse Synthetic Pretraining
configs:
- config_name: preview
  default: true
  data_files:
  - split: preview
    path: previews/representative.parquet
- config_name: shorts_v7
  data_files:
  - split: train
    path: data/shorts_v7/train/shard-*.tar
  - split: test
    path: data/shorts_v7/test/shard-*.tar
- config_name: tshirt_v7
  data_files:
  - split: train
    path: data/tshirt_v7/train/shard-*.tar
  - split: test
    path: data/tshirt_v7/test/shard-*.tar
- config_name: towel_v7
  data_files:
  - split: train
    path: data/towel_v7/train/shard-*.tar
  - split: test
    path: data/towel_v7/test/shard-*.tar
- config_name: genesis_partnet_50k
  data_files:
  - split: train
    path: data/genesis_partnet_50k/train/shard-*.tar
  - split: test_similar
    path: data/genesis_partnet_50k/test_similar/shard-*.tar
  - split: test_unseen
    path: data/genesis_partnet_50k/test_unseen/shard-*.tar
- config_name: kubric_50k_v2
  data_files:
  - split: train
    path: data/kubric_50k_v2/train/shard-*.tar
  - split: test
    path: data/kubric_50k_v2/test/shard-*.tar
- config_name: trajectory_index
  data_files:
  - split: all
    path: index/*/*/shard-*.parquet
---

# PointZero Sparse Synthetic Pretraining

Sparse, training-ready synthetic trajectories associated with
[PointZero: 3D Point Track Completion for Learning Transferable 3D Dynamics](https://arxiv.org/abs/2609.19142).

**Release candidate: uploading and validation in progress.** This repository is
private staging until its license and the full release checks are finalized.
Check `release-status.json` for committed shard counts. The table below describes
the frozen intended source inventory, not a claim that every shard is uploaded.

This release covers synthetic pretraining and its original synthetic evaluation
splits only. It contains 290,097 intended training trajectories
(2,900,970 frames), and 322,230 trajectories including evaluation.
Real-world recordings, robot demonstrations, model predictions, and checkpoints
are outside this release.

The default viewer shows 33 representative thumbnails from the validated pilot.
These previews are separate from the full training/evaluation shards.

## Contents and original splits

| Component | Split | Source scene entries | Trajectories | Frames |
|---|---|---:|---:|---:|
| shorts_v7 | train | 6,885 | 68,712 | 687,120 |
| shorts_v7 | test | 20 | 200 | 2,000 |
| tshirt_v7 | train | 6,593 | 65,788 | 657,880 |
| tshirt_v7 | test | 20 | 200 | 2,000 |
| towel_v7 | train | 5,426 | 54,190 | 541,900 |
| towel_v7 | test | 20 | 199 | 1,990 |
| genesis_partnet_50k | train | 5,058 | 50,576 | 505,760 |
| genesis_partnet_50k | test_similar | 1,600 | 16,000 | 160,000 |
| genesis_partnet_50k | test_unseen | 1,534 | 15,339 | 153,390 |
| kubric_50k_v2 | train | 5,179 | 50,831 | 508,310 |
| kubric_50k_v2 | test | 20 | 195 | 1,950 |

A scene may contain multiple context trajectories. These are different counting
units. Original scene split manifests are preserved under `splits/`, with SHA256
digests in `manifests/source-inventory.json`. PartNet's `test_similar` and
`test_unseen` are separate splits.

## Shard format

Each approximately 1 GB uncompressed TAR is a WebDataset shard. Members for one
trajectory are adjacent and share a stable key:

```text
data/shorts_v7/train/shard-000000.tar
    shorts_v7__000603__0000.points.npy
    shorts_v7__000603__0000.graspers.npy
    shorts_v7__000603__0000.rgb_000.png
    shorts_v7__000603__0000.segmentation_000.png
    ... remaining RGB and segmentation frames ...
    shorts_v7__000603__0000.json
```

| Field | Meaning |
|---|---|
| `points.npy` | float32 array `[T<=10, N<=1000, XYZ=3]`; point index correspondence is preserved across time |
| `graspers.npy` | optional float32 array `[G, T<=10, XYZ=3]` containing recorded interaction tracks |
| `rgb_000.png` ... `rgb_009.png` | exact original PNG bytes for all ten timesteps |
| `segmentation_000.png` ... `segmentation_009.png` | exact original segmentation PNG bytes |
| `json` | component, split, source scene/context IDs, timestep names, image dimensions, sampling method, and hashes |

The arrays preserve source training coordinates and float32 precision. The export
does not normalize, transform, resample, or regenerate point tracks. This sparse
release does not include original dense geometry, depth maps, camera calibration,
or per-frame visibility labels. `first_step` names describe the existing sparse
cache convention; they are not newly computed visibility annotations.

Rigid trajectories use the existing first-step FPS cache; the other components
use the existing first-step sparse cache. Articulated and rigid trajectories
normally have no recorded grasper array: PointZero generates conditioning tracks
from moving points during batch preparation.

Some rigid trajectories contain fewer than 1000 points in their existing FPS cache.
The export preserves those counts; batching uses the existing PointZero padding behavior.

## Short source sequences

Some source cloth trajectories contain only 2–8 frames. Their available points,
interaction tracks, and images are preserved exactly and their metadata records
`quality.default_training_eligible: false`. The `frames` column of each Parquet
index records the actual frame count. The supplied adapter excludes sequences
shorter than ten frames from default training; setting `training=False` retains
all available sequences for inspection. No missing frames are synthesized.

Until the full audit completes, frame totals in the inventory table are nominal
counts at ten frames per trajectory. The final validation report will record
actual frame totals and the number of short source sequences.

## Download one component and train without extraction

```python
from huggingface_hub import snapshot_download

root = snapshot_download(
    repo_id="bartduis/pointzero-synthetic",
    repo_type="dataset",
    allow_patterns=[
        "data/shorts_v7/train/*.tar",
        "manifests/shards/shorts_v7/train/*.json",
        "pointzero_shards.py",
    ],
    # Set revision to the published immutable release commit for reproducibility.
)

import sys
sys.path.insert(0, root)
from pointzero_shards import PointZeroShardDataset
from torch.utils.data import DataLoader

dataset = PointZeroShardDataset(root, components=["shorts_v7"], epoch_samples=10000)
# Use PointZero's existing utils.collate.collate_pad for mixed grasper counts.
from utils.collate import collate_pad
loader = DataLoader(dataset, batch_size=8, num_workers=4, collate_fn=collate_pad)
for epoch in range(10):
    dataset.set_epoch(epoch)
    for batch in loader:
        points = batch["current_scene"]["points"]
        # Pass the batch through the existing PointZero batch preparation/model.
```

`epoch_samples` is per distributed rank. Do not attach a DistributedSampler:
the iterable adapter handles distributed/worker iteration. Training intentionally
samples with replacement, with independently seeded worker streams; shuffle order
differs from the original directory loader. Evaluation partitions shards across
ranks and workers and traverses every sample once. Set `training=False` for exact
traversal, including when inspecting a train split.

The adapter returns PointZero's `current_scene` and `context` structure. RGB and
segmentation conditioning use the first timestep, matching the inspected loader;
all other images remain available in the archive. The dataset supports standard
WebDataset readers too. Parquet indexes provide each sample's shard, TAR byte
offset, and byte length for local random access.

## Component sampling

The adapter's default weights reproduce the inspected runnable configuration:
shorts/T-shirt/towel each 0.33, articulated 1.0, rigid 0.33, normalized across
selected components. These rounded weights differ from the paper's stated
deformable/articulated/rigid mixture of 4/9, 4/9, 1/9. To use that stated mixture:

```python
paper_weights = {
    "shorts_v7": 4/27, "tshirt_v7": 4/27, "towel_v7": 4/27,
    "genesis_partnet_50k": 4/9, "kubric_50k_v2": 1/9,
}
dataset = PointZeroShardDataset(root, weights=paper_weights)
```

Download every selected component's train shards before mixing components.

## Provenance, license, and limitations

Deformable interactions use procedural clothing with FleX physics and Blender
rendering. Articulated interactions use PartNet-Mobility objects in Genesis.
Rigid interactions use modified Kubric scenes. See the paper for generation
details. This is simulation data with sparse surface correspondences; it does
not represent the full diversity or realism of physical interactions.

The release license is pending. No blanket license is assigned to third-party
assets by this staging repository. PartNet-Mobility has noncommercial research
and education terms, recipient-agreement requirements, and upstream ShapeNet
terms; see [the official dataset](https://huggingface.co/datasets/sapien-sim/PartNetMobility).
See `LICENSE.md` and `ATTRIBUTION.md` for the component-specific release record.

## Validation and versioning

The exporter checks 1–10 available frames per trajectory, finite float32 coordinates,
consistent grasper counts, and matching RGB/segmentation dimensions. Only the
explicit source-file allowlist is included. Every released member has a SHA256
digest in its sample metadata, and each shard/index has a digest in
`manifests/shards/`. A pilot validated exact source equivalence, PNG integrity,
indexed access, weighted training, and disjoint distributed evaluation.

The final release will record exact exported counts, any exclusions, and an
immutable Hugging Face revision. Source files are left unchanged.

## Citation

Please cite [PointZero](https://arxiv.org/abs/2609.19142) and the upstream dataset
and generation resources relevant to the components you use. A final BibTeX
entry will be included with the completed release.