lipeize/collsplit-v15-width

collsplit_v15 width label — PRIVATE TRANSFER ARTIFACT

Do not redistribute. This repository is a private machine-to-machine transfer artifact, not a dataset release. Its contents are derived from GraspNet-1Billion, which is licensed for research use; redistributing this data publicly, or to anyone not already covered by that license, is not permitted. The repository is private and must stay private.

Companion repo: lipeize/collsplit-v15-sidecar carries the collision_label/ and meta/ sidecar that this width campaign consumed as input. This repo carries the campaign's output. The sidecar README notes that width_label/ was still being written when that snapshot was taken — this is that missing piece.

What is here

File	Contents
width_label_XXXX.tar.zst	one scene dir XXXX/ of width_label/, holding width_YYYY.npz (one per view)
manifest.json	per shard: scene id, file count, tar byte size, sha256 of the tar
qa.tar.zst	the qa/ directory — the campaign's own QA certificates and audit reports

190 scene shards / 48,639 views / 435.2 GiB. The source tree is 437.0 GiB apparent (438 GiB on disk); the .npz payloads are already deflate-compressed, so zstd -1 only removes tar padding — budget 435.2 GiB for a full pull. manifest.json is the byte authority.

Every scene holds 256 views except scene 0041, which holds 255 by design: width_0255.npz does not exist (v1 pose-gate inheritance), and (41, 255) is the sole certificate exception. A consumer that assumes 256 everywhere will trip on exactly that one view.

Format contract

Read the authoritative spec before consuming these labels: docs/panel_impl/width_v15.md on main in the graspformer repo. Summary:

width_label/<scene:04d>/width_<view:04d>.npz

key	shape / dtype	semantics
w_mid	(N,300,12,4) uint8	mm, half-up interval midpoint (a+b+1)//2; 0 where infeasible
w_margin	(N,300,12,4) uint8	mm, exact b-a; 0 = infeasible — this is the sole feasibility signal
valid	(N,1800) uint8	packbits over (N,14400) C-order; 1 = some campaign wrote the cell
meta	json	version collsplit_width_v15, encoding, tier counts, campaigns, timing

Three things are easy to get wrong:

1. w_margin == 0 is the only feasibility test. Do not infer infeasibility from w_mid == 0 alone as a separate signal — w_mid is forced to 0 wherever the margin is 0, so it carries no independent information there. Degenerate single-bin intervals collapse to margin 0 by definition.
2. valid is bit-packed. Unpack with np.unpackbits(valid, axis=-1)[:, :14400].reshape(N, 300, 12, 4). It marks cells a campaign wrote, which is not the same as feasible.
3. Round-trip the interval, don't use w_mid as a width. The exact endpoints are a = mid - (margin + 1) // 2 and b = mid + margin // 2. mid on its own is lossy by up to 0.5 mm when margin is odd.

Row space N is the collision sidecar's: all un-occluded points of the view, in gid order. Values live on the scan's native 1 mm grid over 0-150 mm (w_cap 0.15). The 10 cm gripper view (executable margin, w_min > 0.1 censoring) is loader arithmetic, not baked into the stored values. The trailing (300, 12, 4) axes are the project's standard 4D grasp cell space: 300 view directions x 12 in-plane rotations x 4 gripper depths.

QA acceptance

All bars were pre-registered before the campaign ran. Report files ship in qa.tar.zst.

check	result	file
completion certificate (full sweep)	PASS — 190 scenes, 0 deferred cells, exclusions [(41, 255)] only	qa_20260803_030753.json
format (sampled)	PASS — 52 views, 0 fails	qa_20260803_030753.json
adoption + scanner parity	PASS — 88 views, 78,682,482 v1 cells, 100% exact (and 100% within 1 mm)	qa_20260803_030753.json
brute accuracy audit	PASS — 9,600 cells (5,760 feasible + 3,840 infeasible), 100% exact, infeasible agreement 1.000, 0 hard flips	brute_audit_20260802_235038.json
twin contrast	PASS — n=1,212 units, median Δmargin +25.75 mm, frac(Δ>0) 0.896, shuffle-null p < 0.001 (measured 0.0)	qa_20260803_033659.json

The twin leg of qa_20260803_030753.json is a dead instrument reading, not a result about these labels. It reports median Δ 0.0 / p 1.0 and pass: false. The cause was an index-ordering bug in the twin QA instrument: annot_cell_to_camera returned its arrays in calculate_4d_coords_rotation's angle-major flattening (j = a*300 + v) while its docstring claimed va-major order, so qa_twin — which indexes va-major — fetched an unrelated cell's mapping on every read, and both twin sides measured corpus base-rate margins. It was root-caused by fingerprinting the sidecar collision channel at the mapped cells (79% C==1 on the alive sides, i.e. the corpus base rate) and fixed in graspformer PR #47, commit 2f8ce2e. qa_20260803_033659.json is the corrected instrument run against the same, already-complete corpus, and is the twin acceptance cited above. The labels were never implicated — the certificate, parity, and brute-audit legs were green throughout, and the corpus was not re-generated between the two runs.

Earlier per-block certificates from the campaign (scenes 1-50, 51-100) are also in qa.tar.zst, along with census_v15.json, shard_plan.json, and the scene-116 pilot.

Download and reconstruct

REPO=lipeize/collsplit-v15-width
export HF_HUB_ENABLE_HF_TRANSFER=1

huggingface-cli download "$REPO" --repo-type dataset \
  --local-dir /datadir2/hf_incoming_width \
  --include 'manifest.json' 'qa.tar.zst' 'width_label_*.tar.zst'

Subsets pick up scenes by glob, e.g. 'width_label_00[0-4][0-9].tar.zst' for scenes 0000-0049. manifest.json and qa.tar.zst are ~200 KiB together and worth taking every time.

Verify against the manifest BEFORE untarring — a truncated shard untars into a plausible-looking partial scene, which is far more expensive to notice later than a hash check now:

cd /datadir2/hf_incoming_width
python - <<'PY'
import hashlib, json, pathlib, sys
man = json.load(open("manifest.json"))
bad, seen = [], 0
for name, rec in man["shards"].items():
    p = pathlib.Path(rec["file"])
    if not p.exists():
        continue                       # shard you chose not to download
    seen += 1
    if p.stat().st_size != rec["tar_bytes"]:
        bad.append(f"{p}: size {p.stat().st_size} != {rec['tar_bytes']}"); continue
    h = hashlib.sha256()
    with open(p, "rb") as f:
        for c in iter(lambda: f.read(8 << 20), b""):
            h.update(c)
    if h.hexdigest() != rec["sha256"]:
        bad.append(f"{p}: sha256 mismatch")
print("\n".join(bad) if bad else f"all {seen} present shards verified")
sys.exit(1 if bad else 0)
PY

Only then unpack:

DEST=$GRASPNET_SAVE_DIR/collsplit_v15
mkdir -p "$DEST/width_label"
for t in width_label_*.tar.zst; do
  nice -n 10 tar -I zstd -xf "$t" -C "$DEST/width_label"
done
tar -I zstd -xf qa.tar.zst -C "$DEST/width_label"   # restores width_label/qa/

Member paths are bare XXXX/. Every shard in this repo — and every shard in lipeize/collsplit-v15-sidecar — stores members as XXXX/<file> with no class prefix. Untar this repo's shards into a dedicated width_label/ destination. Never untar them into the same directory as the sidecar repo's collision_label_* or meta_* shards: the scene dirs would merge and the two label sets would become indistinguishable in place.

Sanity check after unpacking — 189 scenes with 256 files and scene 0041 with 255:

find "$DEST/width_label" -mindepth 1 -maxdepth 1 -type d -not -name qa \
  | while read d; do echo "$(basename $d) $(ls $d | wc -l)"; done | awk '$2!=256'
# expect exactly one line: 0041 255

Integrity

manifest.json carries a sha256 per shard, computed on the tar in the same pass that wrote it, before upload. Every shard's remote byte size was verified against that manifest entry after upload. Verify after download and before untarring, as above.