Realtime-SFT

Realtime-SFT is a 100K-sample streaming-style video question answering dataset constructed from short YouTube videos. Each sample contains a multimodal conversation and frame timestamp metadata that aligns every <|video|> token in the assistant text with one video frame timestamp.

This repository does not redistribute video files. It only provides annotations, YouTube video IDs, and timestamp metadata. Users are responsible for obtaining videos according to YouTube Terms of Service and the original uploaders' licenses.

Dataset Summary

• Samples: 100,000
• Source platform: YouTube
• Unique YouTube videos: 24,817
• Duration bucket: within 4 minutes
• Frame sampling: 1 fps
• Languages: English (93,815), Chinese (6,185)
• Categories: 27
• License for annotations: CC-BY-NC-4.0

Dataset Structure

The dataset has one split, train, stored as Parquet shards:

data/train-00000-of-00002.parquet
data/train-00001-of-00002.parquet

Each row has the following schema:

{
  "id": "rtqa_000000",
  "language": "en",
  "messages": [
    {"role": "user", "content": ""},
    {"role": "assistant", "content": "<|silence|><|video|>..."},
    {"role": "user", "content": "..."},
    {"role": "assistant", "content": "...<|video|>..."}
  ],
  "video": {
    "video_id": "hWYS_j90p-I",
    "category": "Art",
    "subcategory": "ugee_tablet",
    "frame_timestamps": ["00:00", "00:01"]
  }
}

Global metadata files:

• system_prompt.txt: shared system prompt removed from individual rows.
• video_ids.txt: unique YouTube video IDs in the 100K sample.

Special Tokens

• <|video|>: marks the position corresponding to a video frame. The number of <|video|> tokens in the assistant messages equals len(video.frame_timestamps).
• <|silence|>: marks a timestep where the assistant should remain silent.
• <|...|>: turn-break token. Because the dataset is built for real-time streaming, an assistant answer may still be unfolding when the video moves on to a new scene. In that case the model needs to wrap up the current reply quickly and yield so the next turn can respond to the new scene. <|...|> marks exactly that intentional early cut-off — it is a designed token in the conversation, not a text truncation or an ellipsis.

Construction Pipeline

Each sample is produced by a two-phase pipeline that turns a raw video stream into a single, time-aligned multi-turn conversation in which natural language, <|silence|>, and <|video|> tokens all live on the same per-second timeline.

Hierarchical Captioning Base. The pipeline starts from a flattened action sequence {(t_i, c_i)} extracted from a hierarchical caption of the video, where t_i is a per-second timestamp and c_i is a short action / scene description. This sequence is the semantic substrate that the two phases below operate on.

Phase A — Semantic Construction (what to say).

1. Key Event Detection. Scan the action sequence sequentially and select the key change points {k}, filtering trivial transitions and pure context shifts so that only semantically meaningful events remain.
2. Instruction Generation. For each key point k, combine the historical context c_<k with the local change Δ_k and prompt an LLM to write a user instruction Q that asks about a dynamic attribute (action, intent, change of state, etc.).
3. Response Generation. For every segment the LLM also makes a binary speak / stay-silent decision, producing a response sequence a_k of text replies and explicit Silence markers.

Phase B — Temporal Layout & Alignment (when to say it).

4. Temporal Anchor Assignment. Each user instruction is anchored to an arrival timestamp t_q, and the matching reply is sampled inside an interval [p_k, q_k] that models the assistant's implicit reply delay.
5. Tokenization & Padding. Replies are emitted at a dynamic rate in the range [20, 60] tokens/s; idle time steps are filled with <|silence|>, with dedicated handling for truncations and turn transitions.
6. Multimodal Interleaving. User instructions, assistant tokens, silence, and frame-aligned <|video|> slots are merged onto one chronological timeline that becomes a single-turn session.

Multi-Turn Dialogue Assembly. Single-turn sessions from the same video are concatenated, prefixed with the shared system prompt (see system_prompt.txt) and a pure-silence pre-padding to form one streaming dialogue.

Final Training Instance. The resulting sample interleaves dialogue text with <|silence|> and <|video|> tokens along the same per-second timeline, e.g.:

<|silence|><|video|><|silence|> [User: What happened?] <|silence|><|video|> [Assistant: A person enters...] <|silence|><|video|>

This is exactly what the messages field of each row encodes. The total count of <|video|> tokens across all assistant messages equals len(video.frame_timestamps), and <|silence|> marks the time steps where the assistant remains quiet under the streaming protocol.

Loading

Install

pip install -U datasets pyarrow huggingface_hub

Load the train split

from datasets import load_dataset

ds = load_dataset("findcard12138/Realtime-SFT", split="train")
print(ds)
# Dataset({features: ['id', 'language', 'messages', 'video'], num_rows: 100000})
print(ds[0])

This downloads the two Parquet shards (about 95 MB in total) into the Hugging Face cache and returns a Dataset with four fields: id, language, messages, and video.

Streaming mode (no full download)

from datasets import load_dataset

ds = load_dataset("findcard12138/Realtime-SFT", split="train", streaming=True)
for ex in ds.take(3):
    print(ex["id"], ex["language"], len(ex["video"]["frame_timestamps"]))

Filter by language or category

ds = load_dataset("findcard12138/Realtime-SFT", split="train")
en_ds = ds.filter(lambda x: x["language"] == "en")
art_ds = ds.filter(lambda x: x["video"]["category"] == "Art")
print(len(en_ds), len(art_ds))

Rebuild the full chat with the shared system prompt

Every row omits the system message because every example uses the same prompt, stored in system_prompt.txt. Download it once, then prepend it to each row:

from datasets import load_dataset
from huggingface_hub import hf_hub_download

ds = load_dataset("findcard12138/Realtime-SFT", split="train")
system_prompt_path = hf_hub_download(
    repo_id="findcard12138/Realtime-SFT",
    filename="system_prompt.txt",
    repo_type="dataset",
)
with open(system_prompt_path, "r", encoding="utf-8") as f:
    system_prompt = f.read()

def to_chat(example):
    return [{"role": "system", "content": system_prompt}] + example["messages"]

chat = to_chat(ds[0])
for msg in chat[:3]:
    print(msg["role"], "->", msg["content"][:80])

Recover the YouTube URL

example = ds[0]
url = f"https://www.youtube.com/watch?v={example['video']['video_id']}"
print(url)

Read Parquet shards directly

If you prefer raw Parquet I/O without the datasets package:

import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download

shard_path = hf_hub_download(
    repo_id="findcard12138/Realtime-SFT",
    filename="data/train-00000-of-00002.parquet",
    repo_type="dataset",
)
table = pq.read_table(shard_path)
print(table.schema)
print(table.num_rows)

Or with pandas:

import pandas as pd

df = pd.read_parquet(shard_path)
print(df.head())

Video Access

Video files are not included. Each example provides:

• video.video_id: YouTube video ID.
• video.frame_timestamps: timestamps sampled at 1 fps.
• video.category and video.subcategory: original topic labels from data collection.

Users should independently obtain videos and align frames using video.frame_timestamps.

Statistics

Language Distribution

Message Lengths

The shared system prompt is stored separately in system_prompt.txt. Each row therefore contains either 4 messages (single user-assistant turn pair) or 6 messages (two turns).

Frame Timestamp Lengths

len(video.frame_timestamps) per sample, grouped into 1-minute buckets at 1 fps. Summary statistics (min, median, mean, max) appear in the legend title.

Category Distribution

License and Usage

The annotation data in this repository is released under CC-BY-NC-4.0. Videos are not redistributed and remain subject to YouTube Terms of Service and the licenses chosen by their original uploaders.

This dataset is intended for academic research on real-time and streaming video understanding. It should not be used for commercial deployment, face recognition, surveillance, or other applications that may violate privacy or platform terms.

Limitations

• YouTube videos may become unavailable because of deletion, privacy changes, regional restrictions, or account changes.
• Video files are not included, so exact reproducibility depends on the current availability of the original YouTube videos.
• PII, NSFW, and sensitive-content audits have not yet been performed.

Citation

Citation information will be added when available.