VeroMotion is derived from FineVideo, which contains YouTube videos under Creative Commons Attribution licenses. By requesting access you agree to (1) respect the original license of every video, including crediting its creator (channel, title and source URL are provided in every row), (2) honor removal requests and keep your copy up to date, and (3) pass these terms on to anyone you share the data with.

VeroMotion

Video clips where things actually move.

VeroMotion is a collection of short, single-shot video clips that were selected for sustained object motion, built for next-frame prediction, video modelling and world-model research. Most large video corpora are dominated by near-static footage (talking heads, slideshows, locked-off shots). VeroMotion keeps the opposite: clips in which objects keep moving for most of the clip, with camera motion filtered out of the score.

Clips are cut from FineVideo (YouTube videos published under Creative Commons Attribution licenses), kept at their native resolution and frame rate, and shipped with the motion statistics that were used to select them, so you can re-filter to your own taste instead of trusting ours blindly.

Why use it

Motion-first selection. Clips are chosen with an optical-flow filter that subtracts global (camera) translation, then requires object motion to be present in most of the clip, not just a single burst.
No cuts inside a clip. Every clip comes from one continuous shot. Hard cuts are detected and removed, with a small safety margin on both sides of each cut.
Native quality. Original resolution and frame rate are preserved. No resizing, no frame-rate conversion.
Rich per-clip metadata. Four motion scores, scene dynamism, category labels, timestamps in the source video and a direct link back to the source.
Fast random access. Keyframes every 12 frames and faststart MP4, so seeking into a clip is cheap.
Leak-aware splits. train / validation / test are assigned per source video, so two clips from the same video never land in different splits.

At a glance


Source	FineVideo (CC-BY YouTube videos)
Size	~92.6k clips, ~230 GB
Clip length	5 to 20 s (most are about 10 s)
Resolution / fps	Native to the source video (varies per clip)
Codec	H.264 (`libx264`, CRF 21, `yuv420p`), MP4, no audio
Storage	Parquet, one row per clip, raw MP4 bytes in the `video` column
Clips per source video	At most 4
Splits	`train` / `validation` / `test`, roughly 96% / 2% / 2% of source videos
Annotations	Machine-generated (optical-flow statistics; category and dynamism labels inherited from FineVideo)

Quick start

The repository is gated: log in with huggingface-cli login and accept the terms on this page first.

pip install datasets av numpy

import io
import av
import numpy as np
from datasets import load_dataset

# Streaming: nothing is downloaded up front
ds = load_dataset("VeroLM/VeroMotion", split="validation", streaming=True)

row = next(iter(ds))
print(row["clip_id"], row["category"], f'{row["width"]}x{row["height"]} @ {row["fps"]:.2f} fps')
print("object_motion_score:", row["object_motion_score"], "| source:", row["source_url"])

# `video` is raw MP4 bytes. Decode with PyAV (or write it to disk and use OpenCV / ffmpeg).
with av.open(io.BytesIO(row["video"])) as container:
    frames = np.stack([f.to_ndarray(format="rgb24") for f in container.decode(video=0)])
print(frames.shape)  # (T, H, W, 3), uint8

File	What it does
`examples/quickstart.py`	Streams a few clips, prints metadata, decodes frames, saves a sample MP4.
`examples/metadata_only.py`	Reads only the metadata columns (no video bytes) to compute statistics or pick a subset cheaply.
`examples/pytorch_dataset.py`	A `torch.utils.data.Dataset` that returns fixed-size frame windows for next-frame prediction training.
`examples/veromotion_utils.py`	Shared helper for decoding clips into frame arrays.

Re-filtering without downloading videos

The motion scores are plain columns, so you can build a stricter subset before touching any video data. Parquet is columnar, so reading only the metadata columns skips the video bytes:

import pyarrow.parquet as pq
from huggingface_hub import HfFileSystem

fs = HfFileSystem()
files = fs.glob("datasets/VeroLM/VeroMotion/data/train/*.parquet")
cols = ["clip_id", "object_motion_score", "sustained_frac", "duration_s", "width", "height"]
table = pq.read_table(files[0], columns=cols, filesystem=fs)
df = table.to_pandas()
strict = df[(df.object_motion_score > 0.15) & (df.sustained_frac > 0.9)]

See examples/metadata_only.py for the complete version.

Data fields

Column	Type	Description
`clip_id`	string	Unique clip id: `<youtube_id>_<start in ms, zero-padded>`.
`video`	binary	The clip as raw MP4 bytes (H.264, no audio).
`youtube_id`	string	ID of the source YouTube video. Also the unit used for splitting.
`youtube_title`	string	Title of the source video.
`channel`	string	Channel that published the source video. Use it for attribution.
`upload_date`	string	Upload date of the source video, as provided by FineVideo.
`source_url`	string	`https://www.youtube.com/watch?v=<youtube_id>`
`license`	string	Always `CC-BY`: FineVideo only contains Creative Commons Attribution videos.
`start_s`, `end_s`	float	Clip boundaries in seconds within the source video.
`duration_s`	float	Clip length in seconds.
`fps`	float	Frame rate of the clip (same as the source).
`width`, `height`	int	Frame size in pixels (same as the source).
`num_frames`	int	Number of frames in the clip.
`category`, `category_fine`	string	FineVideo's parent and fine-grained content categories.
`motion_score`	float	Mean total optical-flow magnitude (camera motion included), as a percentage of frame width per 5-frame step. Higher means more overall movement in the image.
`object_motion_score`	float	Mean fraction of pixels moving relative to the global camera translation. This is the main selection signal. Range 0 to 1.
`sustained_frac`	float	Fraction of measured frame pairs whose object-motion fraction is at least 0.04. Close to 1 means motion is continuous through the clip.
`scene_dynamism`	float	FineVideo's own per-scene dynamism annotation for the scene the clip came from. Used only as a coarse pre-filter (scenes below 0.5 were skipped).
`split`	string	`train`, `validation` or `test`.

How it was built

In short:

Candidate scenes. Read FineVideo's scene metadata. Skip videos whose category contains interview, news, podcast, lecture or talk show, and skip scenes with dynamism below 0.5.
Cheap analysis. Decode candidate scenes as 128 px-wide grayscale. Analysis is done at low resolution, but the saved clip is cut from the original-resolution video.
Cut detection. Find hard cuts with three criteria combined by OR (absolute frame difference, a spike relative to neighbouring frames, and a histogram change). A false alarm only makes a clip shorter, while a missed cut leaves a cut inside a clip, so the detector is deliberately trigger-happy.
Motion scoring. For frame pairs 5 frames apart (every 2nd pair), compute Farneback optical flow, subtract the median flow (global camera translation), and measure the share of pixels still moving by more than 0.8 px (at analysis resolution). Near-static pairs skip the flow computation.
Selection.
- Cut-free segments of 5 to 12.5 s are kept whole if at least 70% of measured pairs show object motion (at least 4% of pixels) and the clip mean is at least 0.06.
- Segments of 12.5 to 20 s must clear the same test with thresholds 1.3x higher.
- Longer segments are searched for the best non-overlapping 10 s windows.
- Near-black clips are dropped, and at most 4 clips are kept per source video, ranked by object motion.
Encoding. Re-encode the selected span at native resolution and fps: H.264, CRF 21, ultrafast preset, keyframe every 12 frames, audio removed.
Splitting. md5(youtube_id) mod 1000: below 20 is test, 20 to 39 is validation, the rest is train.

Intended uses

Next-frame / video prediction and video generation research.
Pre-training or evaluating video world models on motion-rich data.
Studying motion statistics, or building your own stricter or looser subsets using the provided scores.
Benchmarking video codecs, tracking or optical-flow methods on non-trivial motion.

Limitations and biases

Please read these before building on the data.

The motion filter is heuristic. Thresholds were chosen from pilot runs, not validated against human judgments. Expect some clips that are less dynamic than the scores suggest, and many good clips that were never selected.
Camera model is simple. Camera motion is removed with a single global translation. Zooms, rotations and strong parallax can be counted as object motion.
Not every cut is caught. The detector targets hard cuts. Slow dissolves and fades can slip through.
Lossy second generation. Clips are re-encoded from FineVideo's copy of the YouTube video (CRF 21, ultrafast). Quality is good for modelling but not archival, and inherits whatever compression the source already had.
No audio, no captions, no action labels. There is no text description and no control or action signal. The scores describe how much things move, not what happens.
Content bias. The mix follows FineVideo's category distribution and the motion filter, so it very likely favors categories with lots of physical activity and away from talking-head content (exact category counts are not published here yet; the category column lets you compute them). Interview, news, podcast, lecture and talk-show categories were removed on purpose. Channels with many videos can be over-represented (up to 4 clips per video, no per-channel cap).
Split leakage is only prevented per video. Re-uploads, near-duplicate videos or different videos from the same channel and scene can still appear in different splits.
People are not anonymized. Clips can contain identifiable people and no face blurring was applied. See removal requests below.

Attribution, terms and removal requests

Every clip comes from a video its creator published under a Creative Commons Attribution license. You must credit the creator. channel, youtube_title and source_url are provided for every row.
VeroMotion inherits the usage terms of FineVideo: respect each video's original license, honor removal requests (keep your copy up to date), and if you host or share this data, pass these terms on and require the same agreement. See the original terms on the FineVideo page.
The dataset's license: cc tag is the same coarse label FineVideo uses. The authoritative terms are the per-video Creative Commons Attribution licenses plus the conditions above. This card is not legal advice.
Removal requests: if you are a creator and want a video removed, open a discussion in this repository with the video link and the clip will be taken out.

Citation

If VeroMotion is useful in your work, please cite it, and please also credit FineVideo, which it is built on.

@misc{veromotion2026,
  title        = {VeroMotion: High-Motion Video Clips for Next-Frame Prediction},
  author       = {omurberaisik},
  year         = {2026},
  publisher    = {VeroLM},
  howpublished = {\url{https://huggingface.co/datasets/VeroLM/VeroMotion}}
}

@misc{Farre2024FineVideo,
  title        = {FineVideo},
  author       = {Farr{\'e}, Miquel and Marafioti, Andi and Tunstall, Lewis and von Werra, Leandro and Wolf, Thomas},
  year         = {2024},
  howpublished = {\url{https://huggingface.co/datasets/HuggingFaceFV/finevideo}}
}

About

Created by omurberaisik, published under VeroLM. Feedback, bug reports and removal requests are welcome in the Community tab.

Downloads last month: 15,168

Total file size:

230 GB