inf4d

Private dataset staging for source-bound Infinigen 4D numerical exports and retained review videos. This initial repository is an export/reader development collection, not the final production dataset. Browse uploaded sequences and review videos. catalog.json lists uploaded sequences. inventory/available_scenes.json lists existing local scene files, preview videos and legacy exports for subsequent conversion. Inventory entries are not all uploaded and file counts are not counts of unique physical scenes. inventory/available_configs.json prioritizes ten representative conversion candidates with source checkpoints, camera files, dependency status and explicit blockers. The review archive also includes the existing human/creature/robot small-render collection, content-deduplicated with original paths, ffprobe metadata and local-sidecar availability. Subject tags are source-name hints, not ground-truth semantic labels. Annotated MP4 visualizations do not supply the underlying numerical targets required for training.

Organization

catalog.json                              # uploaded sequences, capabilities and world groups
inventory/available_scenes.json            # conversion backlog and existing source inventory
code/infinigen/p4d/                        # exact bounded CPU dataloader adapter
code/source_hashes.json                    # adapter provenance
code/INFINIGEN_EXPORT_CONTRACT.md           # field semantics and intended full contract
sequences/<sequence_id>/sequence.json       # domain, availability, reader smoke checks
sequences/<sequence_id>/package/            # unchanged native manifest + COMPLETE + artifacts
sequences/<sequence_id>/qa/                 # original validation receipts when available
previews/                                  # review-only videos, separate from training RGB

Every package remains p4d.native_supervision.v1; its original manifest, resource paths, SHA256 hashes and COMPLETE seal are unchanged. The adapter returns inputs, targets, meta. Samples are individual synchronized camera/time observations; sparse exported clocks are not continuous videos. frames, views, resolution and render quality are recorded per sequence. All current sequences belong to pilot; future train/validation/test splits must reconcile source ancestry and keep the same physical world and its camera/activity variants together using physical_world_group; initial source hashes alone do not prove that all sibling variants have been grouped. Do not randomly split observations across those sets.

Search numerical episodes

metadata/sequences.jsonl is the numerical episode table; metadata/previews.jsonl is the encoded-video review table; metadata/conversion_queue.jsonl tracks sources that still need conversion. Each numerical row records scene type, camera count and IDs, available camera models/path families, resolution, exported clocks and timestamps, frame counts, cadence, source duration, capability masks, mesh/material/native resource availability, source hashes and validation references. Unknown fields stay null.

duration_seconds is playback length only for a continuous numerical timeline with complete camera coverage. Sparse exported clocks have null duration even when the source or preview is long. No current pilot is marked production-ready. Filtering uses production-ready entries by default; set status="pilot" to inspect development exports.

After the download and sys.path setup below:

from infinigen.p4d.inf4d_index import query_dataset
long_episodes = query_dataset(root, duration_gt=30)
short_labs = query_dataset(root, scene_types=["laboratory"], duration_lte=5,
                          min_cameras=2)
pilots = query_dataset(root, status="pilot", min_cameras=2)

Durations are seconds. These filters operate on numerical coverage, not MP4 lengths. The index supports strict/inclusive duration bounds, scene types, camera-count bounds and required stored capabilities. Source semantic labels remain separate from filename hints in previews. Camera families are recorded only when declared by the source.

Load an uploaded sequence

Install NumPy and huggingface_hub, authenticate to this private repository, then:

import json, sys
from pathlib import Path
from huggingface_hub import snapshot_download

# For reproducible training, set revision to a full repository commit SHA.
root = Path(snapshot_download('smerkd/inf4d', repo_type='dataset', local_dir='inf4d_local'))
sys.path.insert(0, str(root / 'code'))
from infinigen.p4d.native_supervision_reader import NativeSupervisionDataset, NativeCorrespondenceDataset

catalog = json.loads((root / 'catalog.json').read_text())
sequence = catalog['sequences'][0]
package = root / sequence['package_path']
options = dict(max_decoded_bytes=2 * 1024**3, max_stored_bytes=8 * 1024**3,
               cache_meshes=True)
dataset = NativeSupervisionDataset(package,
    targets=['pointmap', 'depth_z', 'normal_geom', 'geometry_valid', 'instance_id'], **options)
item = dataset[0]  # inputs / targets / meta, NumPy arrays; no Blender required

# Exact same-material surface replay and world displacement for committed pairs.
manifest = json.loads((package / 'manifest.json').read_text())
requests = [(p['source_index'], p['target_index']) for p in manifest['correspondence_pairs']]
correspondence = NativeCorrespondenceDataset(package, requests, **options)
if len(correspondence):
    pair = correspondence[0]
    flow = pair['targets']['scene_flow']
    valid = pair['targets']['scene_flow_primary_valid']

Use local_dir to materialize real files; the native reader intentionally rejects cache symlinks escaping the package. For selective downloads, the bundled infinigen.p4d.inf4d_hub_reader.download_sequence pins one repository revision, downloads only the selected package and verifies its committed hashes.

The map-style datasets can be passed to PyTorch DataLoader. Prefer batch_size=None or a custom collator for variable image sizes and fields. Each worker has its own bounded cache; size worker counts against the declared decoded-memory budget. GT bindings, materials, Gaussians and future motion stay in targets/private state, never encoder inputs.

Available signals and qualification

Native packages include lossless observed RGB arrays, calibrated camera poses/intrinsics, finite first-surface geometry, geometric normals, instance IDs, material-bound mesh state, source provenance and explicitly qualified correspondence/visibility caches where present. Scene flow is world displacement, not camera-frame velocity. Static and moving surfaces remain available; visibility and correspondence validity are distinct.

Read each manifest's capability flags. Current native pilots do not provide whole-scene patched optical layered depth, volume supervision or certified Gaussian footprints, and smooth shading normals/material channels may be unsupported and masked. Separate optical fixture validation does not certify these packages. dataset_accepted=false is preserved; reader verification is not full production acceptance. Human/creature diagnostics and low-sample RGB images are explicitly marked as pilots, not realistic full scene episodes.

Reconstruct layers from saved meshes and materials

The bundled reader exposes a bounded CPU query at the saved scene clock:

from infinigen.p4d.native_supervision_reader import NativeSupervisionReader
reader = NativeSupervisionReader(package, **options)
layers = reader.geometric_layers(0, [[32.5, 24.5]],
                                 mode="transparency_filtered", max_layers=16)
depth = layers["targets"]["layer_depth_z"]
normals = layers["targets"]["layer_normal_geom"]

This reconstructs straight-ray surface layers, exact triangle geometric normals, material and instance ownership from exported native meshes/material recipes. Transparency filtering continues only through supported known transparent materials; unknown shader behavior has explicit masks. It is not a refracted optical ray tracer or a smooth shading-normal substitute. Source-bound sparse validation receipts are listed under reconstruction_validation; they do not qualify every pixel of a scene. Large scene acceleration budgets must be selected explicitly. Renderer optical packet qualification remains separate and cannot be inferred from these geometric tests.

Sources and access

This repository is private. Preserve per-scene source and license records. The bundled Infinigen adapter code retains its BSD-3-Clause notice (code/LICENSE). No blanket dataset license is asserted: BEDLAM/body/clothing and other imported assets retain their source terms, and public redistribution requires a separate asset-by-asset review. Native source archives and shader recipes are data resources, not executable dataloader requirements.

Optional optical diagnostics for the native glass regression remain unqualified for full-scene acceptance. They preserve repeated native surface hits and use their own resolution/calibration; refracted XYZ comes from the patched native Position pass, never camera-depth backprojection. The parent committed manifest remains unchanged. After downloading the sidecar directory as well as its numerical package:

from infinigen.p4d.native_optical_sidecar_reader import NativeWithOpticalSidecar
loader = NativeWithOpticalSidecar(native_reader, sidecar_directory)
observation = loader.sample(0, include_optical=True)
optical_targets = observation["targets"]["optical"]

The Hugging Face metadata configurations are numerical_index (pilot) and preview_index (review), for example datasets.load_dataset(repo_id, "numerical_index", split="pilot"). These are searchable metadata rows; numerical arrays still use the bundled committed native reader. JSONL remains the metadata authority if a hosted viewer cannot display heterogeneous fields. Neither split denotes a production training split.

Curation

Failed and superseded motion experiments are removed from the active dataset. metadata/retired_entries.json records content hashes, reasons and prior source metadata. Those entries are excluded from consolidation and deleted from the current HF tree. Original source assets and failure evidence remain archived locally for development. Remaining entries still require their stated production checks; curation does not change acceptance flags.