Video_VJEPA_CMPR_ADJ

Compressed V-JEPA 2.1 tubelet latents with SoftTOME (Moore-adjacent) merges, derived from VideoChat3 Stage-3 training videos.

Each example is a 16-second / 64-frame clip compressed to a fixed set of 1536 tokens of dimension 768, plus SoftTOME (t, x, y) centroids and — for continuation shards — per-token saliency / importance mass.

This is a derived latent dataset. It does not redistribute the original mp4 videos.

---

Parent dataset

Source videos: VideoChat3 Stage-3 training media
(VideoChat3-Stage3-Training-Data video pool; ~9.2k mp4s in the run that produced these shards).

VideoChat3 is the fully open video MLLM / data stack from MCG-NJU (Academic2M / LV116K / OL617K curriculum). Stage-3 focuses on long-form / streaming-style video supervision. See:

• Paper: VideoChat3 (arXiv:2607.14935)
• Project: MCG-NJU/VideoChat3

This repo only stores downstream SoftTOME latents computed from those videos.

---

What this dataset contains

Repository layout

shards/                              # initial run: tensor + centroids (NO saliency)
  shard_0000.tar … shard_0010.tar
tar_continuation_importance/         # continuation: tensor + centroids + saliency
  shard_0011.tar … shard_0017.tar

• Shards are rolled at a soft cap of ~50 GiB of on-disk .pt files (local packing), then tarred and uploaded.
• After a successful Hub upload, the corresponding local shard directory is deleted on the producer machine.
• Continuation uploads go under tar_continuation_importance/.

Inside each shard_XXXX.tar

A tar of a directory named shard_XXXX/ containing many files:

shard_XXXX/
  {video_key}_{k}.pt
  {video_key}_{k}.pt
  ...

• video_key: stable id = sanitized relative stem + short path hash (avoids basename collisions).
• k: 1-based chunk index along the video timeline (floor(T/64) non-overlapping 64-frame windows; trailing remainder < 64 frames is dropped).

Inside each {video_key}_{k}.pt

torch.load(...) yields a dict:

Key	Shape / type	Meaning
tensor	[1536, 768] float32	SoftTOME-compressed V-JEPA latents for this 64-frame chunk
centroids	[1536, 3] float32	Final SoftTOME centroids, layout (t, x, y) in tubelet-grid coordinates
saliency	[1536] float32	Final SoftTOME saliency / importance mass per survivor — present in tar_continuation_importance/; absent in early shards/shard_0000–0010
stem	str	Same as video_key
chunk	int	Chunk index k
meta	dict	e.g. frames=64, centroid_layout="t,x,y", centroid_space="tubelet_grid", score_kind="softtome_saliency" (when saliency is written)

Grid geometry (per 64-frame chunk):

• Input clip: [64, 384, 384, 3] (after preprocess)
• V-JEPA tubelets: temporal 64/2=32, spatial 384/16=24 → N = 32×24×24 = 18432 tokens
• SoftTOME keep ratio 1/12 → K = 1536 survivors
• Centroids are the final merged SoftTOME centroids (mass-weighted averages on the tubelet grid), sorted in the same order as tensor rows (sort key uses SoftTOME internal (t, y, x) then remapped to stored (t, x, y)).
• When present, saliency[i] is aligned with tensor[i] and centroids[i] (same survivor order).

---

Saliency / importance score

Continuation shards (tar_continuation_importance/shard_0011 … 0017) store a per-survivor importance vector:

Field	Value
Key	saliency
Shape / dtype	[1536] float32
Meta flag	meta["score_kind"] == "softtome_saliency"
Alignment	Same row order as tensor and centroids

What it is

1. Col-Ln produces raw tubelet saliency scores over the full V-JEPA token grid (N = 18432).
2. Those scores are min–max normalized per chunk before SoftTOME.
3. SoftTOME merges Moore-adjacent nodes; each survivor carries a merged mass S (importance accumulated through merges).
4. The stored saliency vector is that final post-merge mass for each of the K = 1536 survivors — not the pre-merge Col-Ln map, and not a separately trained importance head.

How to use it

• Treat as a within-chunk relative importance ranking / weighting over the 1536 SoftTOME tokens.
• Useful for importance sampling, token dropout curricula, or coordinate-conditioned memory that also conditions on mass.
• Do not assume globally calibrated scores across videos or chunks: per-chunk min–max Col-Ln + SoftTOME merges make cross-chunk comparison approximate only.

Shard coverage

Path	Has saliency?
shards/shard_0000.tar … shard_0010.tar	No (tensor + centroids only; load with obj.get("saliency"))
tar_continuation_importance/shard_0011.tar … shard_0017.tar	Yes

saliency = obj.get("saliency")  # None on early shards
if saliency is not None:
    assert saliency.shape == (1536,)
    assert obj["meta"].get("score_kind") == "softtome_saliency"
    # e.g. top-k survivors by importance
    top = torch.topk(saliency, k=64)

---

Processing pipeline

End-to-end (producer):

1. Decode (one ffmpeg pass per mp4)

   • Prefer NVDEC (h264_cuvid / similar) with a CPU ffmpeg pool in parallel
   • Filter: fps=4, short-side 438, center crop 384×384
   • Output full timeline array [T, 384, 384, 3] uint8 RGB

2. Chunk

   • Non-overlapping 64-frame windows (= 16 s at 4 fps)
   • Drop trailing remainder if T % 64 != 0

3. Encode + compress (GPU)

   • Backbone: V-JEPA 2.1 ViT-B (ema_encoder, 384 / 64-frame / tubelet 2 / patch 16)
   • ImageNet mean/std norm on the clip
   • Col-Ln saliency over tubelets → per-chunk min–max normalize → SoftTOME merge mass S
   • SoftTOME GPU / Triton path with Moore-adjacent merges (dot_backend=triton_cost), target budget 1536
   • Emit (tensor, centroids, saliency) per chunk on the continuation run (score_kind=softtome_saliency)

4. Write

   • Atomic .pt writes under rolling shard_XXXX/ directories
   • Optional source-mp4 deletion only after all expected chunks for that video verify on disk

5. Publish

   • When a shard is no longer the active write target and its size/file count is unchanged for ≥ 3 minutes, tar → upload here → delete local tar + shard dir
   • Continuation shards upload under tar_continuation_importance/

Load example

import tarfile
import torch

tar_path = "shard_0000.tar"
with tarfile.open(tar_path, "r") as tf:
    # members look like: shard_0000/<video_key>_<k>.pt
    member = next(m for m in tf.getmembers() if m.name.endswith(".pt"))
    f = tf.extractfile(member)
    obj = torch.load(f, map_location="cpu", weights_only=False)

z = obj["tensor"]          # [1536, 768]
coords = obj["centroids"]  # [1536, 3]  (t, x, y)
saliency = obj.get("saliency")  # [1536] if present (continuation)
print(obj["stem"], obj["chunk"], z.shape, coords.shape, None if saliency is None else tuple(saliency.shape), obj.get("meta"))

---

Intended use

• Precomputed visual memory / JEPA-style latent streams for training models that consume SoftTOME tokens + coordinates
• Research on compressed video tokens, temporal order, and coordinate-conditioned memory

Not a drop-in replacement for the original VideoChat3 QA / conversation annotations (those are not included here).

---

Limitations / notes

• Videos shorter than 16 s (after 4 fps sampling) produce zero chunks and are skipped.
• SoftTOME is stochastic (seeded); centroids are continuous tubelet-grid values after merges.
• saliency is continuation-only (tar_continuation_importance/). Early shards/ tars lack it; always use obj.get("saliency").
• Saliency is post SoftTOME merge mass after per-chunk Col-Ln min–max — comparable within a chunk, not a globally calibrated importance score.
• Early producer runs (shards/0000–0010) may have inflated on-disk size (54 MiB/file) from saving batch views without cloning storage; the logical tensors remain correct ([1536,768] + [1536,3]). Continuation writes .clone() before save (4.5 MiB/file) and include saliency.
• Full producer run for this card: shard_0000 … shard_0017 uploaded (compress finished; ~74.8k continuation chunks + earlier phase-1 shards).

---

Citation

If you use these latents, please cite VideoChat3 (parent videos) and the V-JEPA / SoftTOME methods as appropriate:

@article{videochat3,
  title={VideoChat3: Fully Open Video MLLM for Efficient and Generalist Video Understanding},
  year={2026},
  eprint={2607.14935},
  archivePrefix={arXiv}
}

Upstream V-JEPA 2 / SoftTOME references should be added by downstream users according to the exact backbone and compressor checkpoints they rely on.