| --- |
| license: cc0-1.0 |
| pretty_name: Dancing Stick Figures |
| language: |
| - en |
| task_categories: |
| - text-to-video |
| - text-to-image |
| - unconditional-image-generation |
| - image-to-video |
| - keypoint-detection |
| tags: |
| - synthetic |
| - video-diffusion |
| - motion |
| - stick-figure |
| - benchmark |
| - toy-dataset |
| size_categories: |
| - 100K<n<1M |
| dataset_info: |
| - config_name: frames |
| features: |
| - name: color |
| dtype: image |
| - name: text |
| dtype: string |
| - name: depth |
| dtype: image |
| - name: normal |
| dtype: image |
| - name: seg |
| dtype: image |
| - name: sample_id |
| dtype: string |
| - name: clip_id |
| dtype: string |
| - name: frame_idx |
| dtype: int32 |
| - name: n_frames |
| dtype: int32 |
| - name: fps |
| dtype: int32 |
| - name: split |
| dtype: string |
| - name: group |
| dtype: string |
| - name: held_out |
| dtype: bool |
| - name: seed |
| dtype: int32 |
| - name: qa_flags |
| dtype: string |
| - name: cam_yaw |
| dtype: float32 |
| - name: cam_pitch |
| dtype: float32 |
| - name: cam_center_x |
| dtype: float32 |
| - name: cam_center_y |
| dtype: float32 |
| - name: px_per_m |
| dtype: float32 |
| - name: stroke |
| dtype: float32 |
| - name: bone_scale |
| dtype: string |
| - name: joint_xyz |
| dtype: binary |
| - name: joint_xy |
| dtype: binary |
| - name: joint_depth |
| dtype: binary |
| - name: joint_visible |
| dtype: binary |
| - name: root_pos |
| dtype: binary |
| - name: root_vel |
| dtype: binary |
| - name: root_heading |
| dtype: binary |
| splits: |
| - name: train |
| num_examples: 385920 |
| - name: validation |
| num_examples: 48240 |
| - name: test |
| num_examples: 48240 |
| - config_name: mini |
| features: |
| - name: color |
| dtype: image |
| - name: text |
| dtype: string |
| - name: seg |
| dtype: image |
| - name: sample_id |
| dtype: string |
| - name: clip_id |
| dtype: string |
| - name: frame_idx |
| dtype: int32 |
| - name: n_frames |
| dtype: int32 |
| - name: fps |
| dtype: int32 |
| - name: split |
| dtype: string |
| - name: group |
| dtype: string |
| - name: held_out |
| dtype: bool |
| - name: seed |
| dtype: int32 |
| - name: qa_flags |
| dtype: string |
| - name: cam_yaw |
| dtype: float32 |
| - name: cam_pitch |
| dtype: float32 |
| - name: cam_center_x |
| dtype: float32 |
| - name: cam_center_y |
| dtype: float32 |
| - name: px_per_m |
| dtype: float32 |
| - name: stroke |
| dtype: float32 |
| - name: bone_scale |
| dtype: string |
| - name: joint_xyz |
| dtype: binary |
| - name: joint_xy |
| dtype: binary |
| - name: joint_depth |
| dtype: binary |
| - name: joint_visible |
| dtype: binary |
| - name: root_pos |
| dtype: binary |
| - name: root_vel |
| dtype: binary |
| - name: root_heading |
| dtype: binary |
| splits: |
| - name: train |
| num_examples: 385920 |
| - name: validation |
| num_examples: 48240 |
| - name: test |
| num_examples: 48240 |
| - config_name: motion |
| features: |
| - name: text |
| dtype: string |
| - name: group |
| dtype: string |
| - name: clip_id |
| dtype: string |
| - name: held_out |
| dtype: bool |
| - name: split |
| dtype: string |
| - name: seed |
| dtype: int32 |
| - name: fps |
| dtype: int32 |
| - name: n_frames |
| dtype: int32 |
| - name: frame0_basis |
| dtype: binary |
| - name: posed_joints |
| dtype: binary |
| - name: local_rot_mats |
| dtype: binary |
| - name: global_rot_mats |
| dtype: binary |
| - name: root_positions |
| dtype: binary |
| - name: smooth_root_pos |
| dtype: binary |
| - name: global_root_heading |
| dtype: binary |
| - name: foot_contacts |
| dtype: binary |
| splits: |
| - name: train |
| num_examples: 1072 |
| - name: validation |
| num_examples: 134 |
| - name: test |
| num_examples: 134 |
| configs: |
| - config_name: frames |
| default: true |
| data_files: |
| - split: train |
| path: frames/train-*.parquet |
| - split: validation |
| path: frames/val-*.parquet |
| - split: test |
| path: frames/test-*.parquet |
| - config_name: motion |
| data_files: |
| - split: train |
| path: motion/train-*.parquet |
| - split: validation |
| path: motion/val-*.parquet |
| - split: test |
| path: motion/test-*.parquet |
| - config_name: mini |
| data_files: |
| - split: train |
| path: mini/train-*.parquet |
| - split: validation |
| path: mini/val-*.parquet |
| - split: test |
| path: mini/test-*.parquet |
| --- |
| |
| # Dancing Stick Figures — v0.2 |
|
|
| **A small, fully-labelled synthetic video dataset for learning (and teaching) video diffusion on one consumer GPU.** |
|
|
| 1,340 clips · 6 s @ 20 fps · 128×128 RGBA · 482,400 frames · 134 text prompts × 10 seeds × 3 cameras · |
| every frame carries the 3D skeleton, camera and G-buffer (depth, normals, part segmentation) that produced it. |
|
|
| <p align="center"><img src="figs/dataset_contact_sheet.png" width="900"></p> |
|
|
| Think of it as an *MNIST for video generation*: small enough that a 64² video diffusion model trains from scratch |
| in a few hours on a 24 GB card, structured enough that you can **measure** what the model got wrong (missing arm? |
| detached leg? wrong colour?) instead of eyeballing it. It is also a clean playground for the "image model first, |
| then video" curriculum used by Seedance-class systems. |
|
|
| > **Start here →** [](https://colab.research.google.com/github/sprited-ai/dancing-stick-figures/blob/main/notebooks/dancing_stick_figures_colab.ipynb) |
| > **one route, end to end, sized for a 16 GB T4:** look at the data → train a 64² image model → warm-start a video model from |
| > it → watch the GIF → measure visible topology and motion. The measured optimization phases take about 25 and 22 minutes; |
| > validation and diffusion sampling add time afterward. Same five commands in the |
| > [code repo README](https://github.com/sprited-ai/dancing-stick-figures#the-route-colab-t4-1-h--rtx-4090-20-min). |
| > |
| > **Sibling dataset:** [sprited/dancing-chibi-figures](https://huggingface.co/datasets/sprited/dancing-chibi-figures) — the same motions and cameras rendered as a volumetric chibi character (paired by `clip_id`). |
| > |
| > **v0.2 uses an in-domain seed split.** Captions remain the raw motion prompts. Seeds 0--7 train, seed 8 validates, |
| > and seed 9 tests; every split contains all 134 prompts. Nine of the original 143 prompts were removed after visual |
| > QA because their motions do not visibly perform the requested action (see the curation note below). Feedback and |
| > issues are welcome. |
| |
| ## Which config? |
| |
| | config | rows | size | contents | |
| |---|---|---|---| |
| | `frames` (default) | 482,400 frames | 4.4 GB | 128² RGBA colour + depth16 + normals + seg + all labels | |
| | `mini` | 482,400 frames | 0.79 GB | **64²** RGBA colour + seg + all labels — laptops, Colab, classrooms | |
| | `motion` | 1,340 clips | 0.33 GB | raw generator output: world joints, rotation matrices, foot contacts | |
| |
| ## Quick start |
| |
| ```python |
| from datasets import load_dataset |
| ds = load_dataset("sprited/dancing-stick-figures", "frames", split="validation") # 128 px frames + labels ("mini" = 64 px, 0.79 GB) |
| row = ds[0] |
| row["color"] # PIL RGBA image (transparent background, colour-coded bones) |
| row["text"] # "A person does the running man dance." |
| import numpy as np |
| xy = np.frombuffer(row["joint_xy"], np.float32).reshape(27, 2) # normalised [0,1] image coords |
| xyz = np.frombuffer(row["joint_xyz"], np.float32).reshape(27, 3) # metres, figure frame (x left, y up, z fwd) |
| vis = np.frombuffer(row["joint_visible"], np.uint8) # 1 = joint visible in this camera |
| ``` |
| |
| Motion (one row per clip, raw generator output): |
| |
| ```python |
| mo = load_dataset("sprited/dancing-stick-figures", "motion", split="validation")[0] |
| T = mo["n_frames"] |
| P = np.frombuffer(mo["posed_joints"], np.float32).reshape(T, 27, 3) # world, metres |
| Rl = np.frombuffer(mo["local_rot_mats"], np.float32).reshape(T, 27, 3, 3) # per-joint local rotations |
| fc = np.frombuffer(mo["foot_contacts"], bool).reshape(T, 4) |
| ``` |
| |
| Training a baseline (code: <https://github.com/sprited-ai/dancing-stick-figures>, MIT): |
| |
| ```bash |
| python -m train.cache --data frames --out cache # uint8 memmap of all frames |
| python -m train.video_ddpm --cache cache --size 64 --frames 8 --batch 16 --fast --compile # UNet, ~13 GB |
| python -m train.video_dit_fm --cache cache --size 64 --frames 8 --batch 16 --patch 2 --fast --compile # DiT-FM |
| ``` |
| |
| ## What is in a frame |
| |
| <p align="center"><img src="figs/dataset_labels_row.png" width="1000"></p> |
| |
| *color (RGBA over white) · seg (bone id per pixel) · depth16 · camera-space normals · `joint_xy` overlay (green = visible, red = occluded)* |
|
|
| **`frames` config — one row per rendered frame (482,400 rows).** |
|
|
| | column | type | meaning | |
| |---|---|---| |
| | `sample_id`, `clip_id`, `frame_idx`, `n_frames`, `fps` | str/int | `clip_id = group/prompt_slug_s{seed}/c{cam}`; 120 frames per clip, 20 fps | |
| | `split`, `group`, `held_out` | str/bool | split ∈ train/val/test; group ∈ dance, gesture, locomotion, transitions, idle, sport; `held_out` is false in the current seed split | |
| | `text` | str | the motion prompt the clip was generated from (134 unique) | |
| | `seed` | int | generator seed 0–9 | |
| | `qa_flags` | str | comma list; `levitation` (root ever > 1.6 m above floor), `frozen` (mean joint speed < 0.02 m/s). Kept, not filtered — filter if you like | |
| | `cam_yaw`, `cam_pitch` | float (rad) | orthographic camera; yaw 0 = figure faces the camera, canonical yaws ±6° jitter (70 %) or uniform (30 %); pitch −3°…10° | |
| | `cam_center_x/y`, `px_per_m` | float | projection: `x_px = cx + px_per_m·x`, figure scale 50–58 px/m | |
| | `stroke` | float | line width in px (3–5, per clip) | |
| | `bone_scale` | JSON str | per-bone length multipliers (±8 %, applied to the skeleton) | |
| | `joint_xyz` | binary f32[27,3] | figure-frame 3D joints, metres, Hips at origin | |
| | `joint_xy` | binary f32[27,2] | image coordinates, normalised to [0,1] | |
| | `joint_depth` | binary f32[27] | camera-space depth of each joint (m; same convention as the depth map) | |
| | `joint_visible` | binary u8[27] | 1 if the joint's pixel is not occluded by another bone | |
| | `root_pos`, `root_vel`, `root_heading` | binary f32[3], f32[3], f32[2] | Hips trajectory in the frame-0 figure frame; heading = (cos, sin) yaw | |
| | `color` | image | 128×128 RGBA PNG, **transparent background**, premultiply before compositing | |
| | `depth` | image | 16-bit PNG, `depth = lo + u16/65535·(hi−lo)`, range [−1.5, 1.5] m around the figure, 0 = background | |
| | `normal` | image | RGB PNG, camera-space normal `n = rgb/255·2−1` | |
| | `seg` | image | 8-bit PNG, value = joint id + 1 of the bone owning the pixel (0 = background), majority over a 4×4 supersample → **hard edges** | |
|
|
| Binary columns are raw little-endian arrays: `np.frombuffer(row[col], dtype).reshape(shape)`. |
|
|
| Skeleton (`cskel27`, index order): Hips, Spine, Spine1, Spine2, Spine3, Neck, Head, RightShoulder, RightArm, |
| RightForeArm, RightHand, RightHandEnd, RightHandThumb1, LeftShoulder, LeftArm, LeftForeArm, LeftHand, LeftHandEnd, |
| LeftHandThumb1, RightUpLeg, RightLeg, RightFoot, RightToeBase, LeftUpLeg, LeftLeg, LeftFoot, LeftToeBase. |
|
|
| Colour code (figure's own left/right): head, neck, torso, clavicles **black**; left upper arm ■ `#E84030`, left forearm+hand ■ `#FF9628`; |
| right upper arm ■ `#286EE6`, right forearm+hand ■ `#50C8F0`; left thigh ■ `#C832A0`, left shin+foot ■ `#FF78C8`; |
| right thigh ■ `#1E965A`, right shin+foot ■ `#78DC5A` (`generator/render.py:PALETTE`, keyed by the bone's child joint). |
| Colours are anti-aliased (4× supersampled); if you need hard-edged colour, rebuild it from `seg` + the palette. |
|
|
| **`motion` config — one row per clip (1,340 rows, 327 MB).** Raw output of the motion generator (NVIDIA ARDY): |
| `posed_joints` f32[T,27,3] (world, m), `local_rot_mats` / `global_rot_mats` f32[T,27,3,3], `root_positions`, |
| `smooth_root_pos` f32[T,3], `global_root_heading` f32[T,2], `foot_contacts` bool[T,4], plus `frame0_basis` f32[3,3] |
| (rows = figure-frame x/left, y/up, z/forward in world coordinates; `figure_joints = (posed_joints − Hips) @ basis.T`, |
| before `bone_scale`). Same `clip_id` (minus the camera suffix), `split`, `group` as `frames`. |
|
|
| ## Splits |
|
|
| Split is by **ARDY generation seed**: seeds 0--7 train, seed 8 validation, and seed 9 test. All 134 prompts and all |
| camera families occur in every split, while the underlying source-motion realizations remain disjoint. This is an |
| in-domain generation split; it does not claim zero-shot generalisation to unseen prompt vocabulary. |
|
|
| | | motion clips (×3 cameras) | frames | prompts | |
| |---|---|---|---| |
| | train | 1,072 | 385,920 | 134 | |
| | validation | 134 | 48,240 | 134 | |
| | test | 134 | 48,240 | 134 | |
|
|
| **Prompt curation (v0.2).** Nine of the 143 generated prompts are excluded from the release because their ARDY |
| motions do not visibly perform the requested action in this rendered domain: near-static failures (*sways to slow |
| music*), motion that cannot render (*shakes their head no* — the head is a filled circle), unrecognisable or absent |
| actions (*yoga warrior pose*, *yoga tree pose*, *sit up*, *push up*, *standing long jump* — the figure glides without |
| an airborne phase), interactions with objects that do not exist in the render (*climbs over a low wall*), and |
| *lies down on the floor*. The exclusion list with per-prompt reasons ships as `prompts/v02_excluded.txt` in the code |
| repository. Stillness prompts whose stillness is semantically correct (the idle group, stands-* prompts, *balances on |
| one leg*) are kept even when the `frozen` QA flag fires. |
|
|
| ## How it was made |
|
|
| prompt → **NVIDIA ARDY** text-to-motion (6 s, 20 fps, seeds 0–9) → 27-joint skeleton in a canonical figure frame, |
| per-clip body jitter (bone lengths ±8 %, stroke, scale) → 3 orthographic cameras per clip (70 % from a canonical set of |
| yaws, 30 % uniform) → z-buffered capsule rasteriser writes colour / depth / normal / segmentation in one pass → |
| parquet. Everything is deterministic from `clip_id`; the generator is in the repo (`generator/`). |
|
|
| Motion prompts: 134 hand-written English sentences in 6 groups (dance 33, gesture 29, locomotion 21, transitions 13, |
| idle 10, sport 28); acrobatics and moonwalk were removed during generation QA, and nine further prompts were removed |
| by the v0.2 release curation above (ARDY did not render them faithfully). |
|
|
| ## Historical v0.1 baselines and the structural evaluator |
|
|
| The results below were produced on the original prompt-disjoint v0.1 partition. They document the released |
| checkpoints, but they are not the official v0.2 seed-split baseline; a matched v0.2 reference run is reported separately. |
|
|
| Because every bone has its own colour, a rendered frame can be *parsed*: count colour segments per limb, check they |
| touch their parent, and measure colour purity. The v0.1 files called this rule-based checker **oracle v0**; the current |
| paper uses the more descriptive name **structural evaluator**. It reports: |
|
|
| - **tvr** — topology violation rate: fraction of the eight limb colours whose visible mask has a connected-component |
| count other than one (missing, detached/fragmented, or duplicated colour regions) |
| - **lie** — limb-identity/adjacency error: fraction of the eight expected torso→proximal or proximal→distal colour |
| adjacencies that are absent (a full left/right chain swap preserves this graph and is not detected by v0) |
| - **cpe** — colour purity error: fraction of foreground pixels with an undefined colour |
| - **clean** — fraction of frames with lie = tvr = 0 |
|
|
| Real frames do **not** score 0: an occluded arm looks like a missing arm to a pixel parser. So every number is reported |
| next to the score of real validation frames at the same resolution (the *floor*); a model at the floor makes these |
| kinds of errors no more often than the data itself. The structural evaluator is blind to geometry such as proportions |
| and joint angles; a validated learned rig estimator remains future work. |
|
|
| **Unconditional image models, 512 samples each, 50 sampling steps (oracle v0):** |
|
|
| | model | res | steps | tvr | lie | cpe | clean | floor tvr / lie / clean | |
| |---|---|---|---|---|---|---|---| |
| | UNet, v-pred (`ia64`) | 64² | 30k | .159 | .113 | .041 | .42 | .142 / .106 / .40 | |
| | DiT-FM p4 (`ib64`) | 64² | 30k | .176 | .122 | .040 | .38 | .143 / .108 / .37 | |
| | UNet, min-SNR-5 (`ia64L`) | 64² | 96k | **.134** | .116 | .039 | **.43** | .136 / .103 / .40 | |
| | DiT-FM p2 (`ib64L`) | 64² | 50k | .164 | .114 | .043 | .40 | .139 / .106 / .37 | |
| | UNet, min-SNR-5 (`ia128`) | 128² | 20k | .226 | .073 | .020 | .22 | .203 / .047 / .23 | |
| | DiT-FM p4 (`ib128`) | 128² | 40k | .251 | .065 | .020 | .23 | .209 / .048 / .21 | |
|
|
| <p align="center"><img src="figs/img64_128_final_grids.png" width="1000"></p> |
|
|
| **Video (64², unconditional, UNet 46 M).** Two 8-frame models (from scratch, 85k steps; warm-started from the image model, 61k) and one |
| **autoregressive** model (`--ar_ctx 8`: 8 context + 8 new frames per chunk, 10 fps, rolls out to any length; 60k steps). Oracle vs |
| real clips of the same length: per-frame anatomy within ~0.03 of real, temporal jitter 1.2–1.3× real, FVD ~80–100 above the |
| real-vs-real floor. Full table, checkpoints and GIFs: [sprited/dancing-stick-figures-baselines](https://huggingface.co/sprited/dancing-stick-figures-baselines). |
| Warm-starting from the image model reaches the same loss ~2.5× sooner but converges to the same quality. 5.6-second rollout: |
|
|
| <p align="center"><img src="https://huggingface.co/sprited/dancing-stick-figures-baselines/resolve/main/unet_ar64_rollout.gif" width="512"></p> |
|
|
| DiT-track (Seedance-style two-stage, interim) and class-conditional checkpoints are in the same model repo. |
|
|
| ## Intended use / limitations |
|
|
| - Teaching and prototyping video/image diffusion, motion-conditioned generation, pose estimation from renders, |
| I2V, and structural evaluation. Not a human-motion dataset: it is stick figures with a single body preset (jittered). |
| - Motion realism is bounded by the generator (ARDY); some prompts are only loosely followed. Use `qa_flags` and |
| inspect motion samples when prompt semantics are central to an experiment. |
| - 134 prompts is small for text conditioning; captions are the raw motion prompts. Dense templated captions |
| (camera, body, root motion; dynamic + static) remain future work. |
| - The real-reference TVR is non-zero because occlusion hides coloured limbs at these resolutions (about 14% at 64²). |
|
|
| ## Versioning |
|
|
| - **v0.1 (2026-08-18)** — initial public release: 1,430 clips, `frames` + `motion` configs, oracle v0, image baselines. |
| - **v0.2 (2026-08-25)** — seed-disjoint in-domain train/validation/test partitions, visual-QA prompt curation |
| (143 → 134 prompts), public-motion reconstruction and verification, seeded instructor render variants, |
| prompt-conditioned reference models, and an image-to-video Colab lesson. |
| A learned rig estimator remains future work until its generated-video scores are validated. |
|
|
| ## License and attribution |
|
|
| - **Data (this dataset): CC0-1.0.** Motion was generated with ARDY's 20-fps Core model; the original generation record |
| did not retain the checkpoint revision. ARDY's source code is Apache-2.0; its released checkpoints are governed by the |
| [NVIDIA Open Model Agreement](https://www.nvidia.com/en-us/agreements/enterprise-software/nvidia-open-model-agreement/), |
| which states that NVIDIA claims no ownership of generated outputs. The rendering, labels, and skeleton conventions |
| are ours. |
| - **Code** (generator, trainers, oracle): MIT, <https://github.com/sprited-ai/dancing-stick-figures>. |
|
|
| If you use it: |
|
|
| ``` |
| @misc{dancingstickfigures2026, |
| title = {Dancing Stick Figures: A Synthetic Video Dataset, Renderer, and Diagnostic Evaluation Suite}, |
| author = {Cho, Jin Hyuk}, |
| year = {2026}, |
| url = {https://huggingface.co/datasets/sprited/dancing-stick-figures} |
| } |
| ``` |
|
|
| Made by [Sprited](https://sprited.ai). Questions → open a discussion on this repo. |
|
|
