---
license: apache-2.0
task_categories:
- image-to-video
tags:
- controllable-video-generation
- on-policy-distillation
- benchmark
---

# Dense2Sparse benchmark

[Paper](https://huggingface.co/papers/2607.24731) · [Project Page](https://rethinking-cfg-opd.github.io) · [Code](https://github.com/rethinking-cfg-opd/Rethinking-CFG-OPD) · [Checkpoints](https://huggingface.co/Cuttle-fish-my/Rethinking-CFG-OPD-ckpts)

The complete 600-clip evaluation benchmark from our study of classifier-free guidance in
on-policy distillation — 6 motion-difficulty buckets × 100, built on
[OpenHumanVid](https://huggingface.co/datasets/Owen777/HQ-OpenHumanVid).

**Self-contained: download this and you can run the evaluation.** No OpenHumanVid download, no
annotation pass, no GPU-days of preprocessing.

| | | |
|---|---|---|
| `rgb/` | 600 mp4 | ground-truth clips, 832×480 / 81 frames |
| `reference_image/` | 600 png | frame 0 of each clip — an inference input |
| `dwpose/` | 600 mp4 | DWPose skeleton control |
| `depth/` | 600 mp4 | MiDaS `dpt_hybrid` depth control |
| `scribble/` | 600 mp4 | Informative-Drawings `anime_style` lineart control |
| `_gt_keypoints/` | 600 npz | DWPose keypoints of the GT video — what the pose metric scores against |
| `_gt_keypoints_val/` | 24 npz | DWPose keypoints for the val split, in val row order |
| `metadata.csv` | 600 rows | chunk → prompt; the text conditioning the eval uses |
| `splits/*.filelist.csv` | 600 / 24 / 24075 | the split definitions |

All three control signals are **ours**: OpenHumanVid ships metadata CSVs only — no media, no
pose — so `dwpose/` is DWPose run over its videos by us, exactly like `depth/` and `scribble/`.
All are version-sensitive: a different annotator build gives a different control signal and
therefore different numbers, which is why they are pinned here rather than left to you. Use
`_gt_keypoints/` as shipped for the same reason — the published PCK and MPJPE are scored
against exactly these files.

## Quick start

```bash
huggingface-cli download --repo-type dataset \
    Cuttle-fish-my/Rethinking-CFG-OPD-Dense2Sparse-Dataset \
    --local-dir data/HQ-OpenHumanVid/chunked_832x480_81f_highmotion
```

Then, in the code repo, expand the file lists into the split CSVs the eval code reads and score
a model:

```bash
CHUNKED=data/HQ-OpenHumanVid/chunked_832x480_81f_highmotion
python scripts/data/build_splits_from_filelist.py --data_dir "$CHUNKED" --splits test_set,val_set
python scripts/data/vace_make_union_csv.py        "$CHUNKED" test_set val_set

huggingface-cli download Cuttle-fish-my/Rethinking-CFG-OPD-ckpts \
    --include 'dense-to-sparse-video/*' --local-dir models/released
bash scripts/eval/run_eval_model.sh opd 0,1,2,3 \
    models/released/dense-to-sparse-video/pdm_unicontrol.safetensors pdm
```

`metadata.csv` carries the prompt for each of the 600 chunks. These are OpenHumanVid captions,
included because `build_splits_from_filelist.py` reads prompts from there and inference conditions
on them — the published numbers were produced with these exact strings.

## The validation split

`val_set.filelist.csv` is drawn from the benchmark: all 24 of its chunks are also in
`test_set.filelist.csv`, 4 per motion bucket, and its extra `eval_idx` column is each row's index
into the test file list. Checkpoint selection during training used these 24 clips.

`_gt_keypoints_val/` is the val split's own extraction, not a re-index of `_gt_keypoints/`. Keep
the two separate: each is indexed by its own CSV's row order, so scoring val clips against the
test keypoints would compare every clip to the wrong person. Use both as shipped — training reads
the val set, evaluation reads the test set.

## Training data is not here

Only the 600 benchmark clips ship. The training split is 24 075 chunks (~99 GB once annotated)
and is not redistributed — build it from your own OpenHumanVid copy with
`scripts/data/prepare_training_corpus.sh` in the code repo, which downloads, chunks and
annotates in one resumable pass.

## Provenance

- 832×480, 81 frames, non-overlapping chunks of OpenHumanVid clips (`n_chunks = n_frames // 81`,
  named `<clip_id>_c<index>`).
- The 600 are stratified into 6 buckets of 100 by mean per-frame pixel difference of the rendered
  DWPose skeleton; bucket edges `[1.5, 2.0, 2.5, 3.5, 5.0, 7.0, ∞)`. Difficulty is measured on the
  *control signal*, so it means "how much the pose actually moves" rather than "how pretty the
  clip is" — the two are anti-correlated in OpenHumanVid, whose aesthetic filtering biases toward
  near-static clips.
- The split is fixed by the released file lists; it cannot be re-sampled from the corpus.

`MANIFEST.sha256` covers every file.

## Licence

The annotations, keypoints and split definitions are Apache-2.0.

`rgb/`, `reference_image/` and the prompts in `metadata.csv` are **derived from OpenHumanVid** —
600 clips of 81 frames each plus their captions, redistributed here so the benchmark is runnable
on its own. OpenHumanVid carries its own terms; if
you need the corpus itself, obtain it from its authors and comply with those. If you maintain
OpenHumanVid and would prefer these removed, open a discussion and we will.