license: other
task_categories:
- video-text-to-text
- visual-question-answering
language:
- en
tags:
- video-understanding
- reinforcement-learning
- adaptive-reasoning
size_categories:
- 1K<n<10K
configs:
- config_name: default
data_files:
- split: train
path: train.parquet
EVAThink-Dataset-Stage2
Training data for stage 2 of the two-stage reinforcement learning that produces EVAThink-Qwen3, a video-language model that decides per question whether to answer directly or to write a short evidence-grounded reasoning trace first.
This set holds the remaining gold pairs: every gold pair that is not in the Stage 1 strict set. The other stage is EVAThink-Dataset-Stage1.
What is in it
Every problem is a multiple-choice video question that appears twice, once per view:
- dense view: the evidence fills the clip, so the answer can be read off directly.
- sparse view: the same question on a longer video in which the evidence is diluted, so the model has to locate and connect it.
The two rows of a problem are adjacent in train.parquet (dense first) and share extra_info.problem_id.
| Rows | 8,358 |
| Problems | 4,179 (2 views each) |
| Frames per view | 32 JPEG frames at the source resolution |
| Frame folders | 7,306 (233,792 frames; a sparse-view video can serve several problems) |
Pair type sparse2dense |
2,435 problems |
Pair type dense2sparse |
1,744 problems |
| Median source duration | dense 42 s, sparse 140 s |
| Size | 22.7 GB in 13 zip files |
The two pair types say how the second view was made:
sparse2dense: the original video is the sparse view. The dense view is a shorter clip cut around the annotated evidence.dense2sparse: the original video is the dense view. The sparse view concatenates it with another video, and the question then says which event segment to answer from.
Problems per source (data_source):
| Source | Problems |
|---|---|
Holmes-train |
67 |
LLaVA-Video-178K/2_3_m_academic_v0_1 |
628 |
Molmo2-VideoCapQA |
529 |
NeXT-QA/0_30_s_nextqa |
35 |
NeXT-QA/1_2_m_nextqa |
45 |
NeXT-QA/30_60_s_nextqa |
56 |
PerceptionTest/train |
248 |
SR-91k |
1,682 |
VideoMarathon |
169 |
longvideo-reason |
720 |
Files
train.parquet training rows (frame paths are relative: frames/<frame_dir>/000.jpg ... 031.jpg)
frames_zip/ frames-000.zip ... frames-012.zip, each unpacks into frames/<frame_dir>/
train.preview.jsonl the same rows as readable JSON lines (only the first frame path of each view is listed)
samples.jsonl one line per parquet row: ids, view, answer, accuracy signals, frame folder, source video
ts_map.json frame folder -> source fps, sampled frame indices, total frames, duration
postamble.txt the instruction appended to every question
manifest.json counts, plus size and sha256 of every zip
extract_frames.py unpacks the zips and can write a parquet with absolute paths
Usage
hf download MaplesWCT/EVAThink-Dataset-Stage2 --repo-type dataset --local-dir EVAThink-Dataset-Stage2
cd EVAThink-Dataset-Stage2
python extract_frames.py # verifies sha256, unpacks into ./frames
python extract_frames.py --abs # also writes train.abs.parquet with absolute frame paths
import pyarrow.parquet as pq
rows = pq.read_table("train.parquet").to_pylist()
r = rows[0]
r["prompt"][0]["content"] # "<video>\n" + question + options + instruction
r["videos"][0]["video"] # 32 frame paths, relative to the dataset folder
r["reward_model"]["ground_truth"] # option letter
r["extra_info"]["view"] # "dense" or "sparse"
Fields
train.parquet follows the verl RL data format.
| Field | Meaning |
|---|---|
data_source |
source dataset of the question |
prompt |
one user turn: <video>, the question with options, then the instruction in postamble.txt |
reward_model.ground_truth |
correct option letter |
videos[0].video |
the 32 frame paths of this view |
extra_info.problem_id |
shared by the two views of a problem |
extra_info.view |
dense or sparse |
extra_info.evid_case |
sparse2dense or dense2sparse |
extra_info.dense_acc |
accuracy of direct answers on the dense view |
extra_info.sparse_acc |
accuracy of direct answers on the sparse view |
extra_info.gap |
dense_acc - sparse_acc |
extra_info.sparse_slow_acc |
accuracy on the sparse view when the model reasons before answering |
extra_info.direct_acc |
direct-answer accuracy on this row's own view |
extra_info.src_fps, src_total_frames, src_duration, frames_indices |
where the 32 frames sit in the source video |
All accuracies are measured with Qwen3-VL-8B-Instruct on exactly these 32 frames, from 8 sampled responses per question (temperature 1.0), so they are multiples of 1/8.
Timestamps. Frames are sampled uniformly, first and last frame included. A loader that only sees a folder of JPEGs
cannot know the real frame times, so pass src_fps and frames_indices (also in ts_map.json) to the video processor.
Otherwise every sample looks like the same short clip.
Response format. The instruction asks the model to start either with <answer> (direct answer) or with Alright
(reasoning), and to end with <answer>X</answer>.
How it was selected
A pool of about 118k multiple-choice video questions was filtered into gold pairs: problems whose dense view is
answered directly more reliably than the sparse view (gap at least 0.25), and whose sparse view benefits from reasoning
(sparse_slow_acc - sparse_acc at least 0.25).
This dataset keeps all gold pairs (see below) minus the Stage 1 problems. The two datasets share no problem_id.
How it is used
Stage 2 continues from the Stage 1 checkpoint. Its reward no longer looks at the view: a correct answer is rewarded whether or not the model reasons, with a small bonus for answering directly, so the model keeps reasoning only where it actually helps accuracy.
Both stages train on the two views of a problem in the same update.
Source data
The frames are extracted from videos of the datasets named in data_source. samples.jsonl gives the source video of
every row as a path inside our local copy. The source videos themselves are not redistributed here, and each source
dataset remains under its own license and terms.