EVAThink-Dataset-Stage1

Training data for stage 1 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 strict pairs: problems where the two views separate most clearly. The other stage is EVAThink-Dataset-Stage2.

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	3,532
Problems	1,766 (2 views each)
Frames per view	32 JPEG frames at the source resolution
Frame folders	3,349 (107,168 frames; a sparse-view video can serve several problems)
Pair type sparse2dense	1,150 problems
Pair type dense2sparse	616 problems
Median source duration	dense 37 s, sparse 134 s
Size	10.1 GB in 6 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	28
LLaVA-Video-178K/2_3_m_academic_v0_1	317
Molmo2-VideoCapQA	325
NeXT-QA/0_30_s_nextqa	24
NeXT-QA/1_2_m_nextqa	20
NeXT-QA/30_60_s_nextqa	31
PerceptionTest/train	127
SR-91k	514
VideoMarathon	51
longvideo-reason	329

Files

train.parquet        training rows (frame paths are relative: frames/<frame_dir>/000.jpg ... 031.jpg)
frames_zip/          frames-000.zip ... frames-005.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-Stage1 --repo-type dataset --local-dir EVAThink-Dataset-Stage1
cd EVAThink-Dataset-Stage1
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 dense_acc >= 0.75 and sparse_slow_acc - sparse_acc >= 0.5. On the dense view the base model usually answers correctly without reasoning, and on the sparse view reasoning lifts its accuracy by at least 0.5.

How it is used

Stage 1 starts from Qwen3-VL-8B-Instruct. Its reward depends on the view: on top of answer correctness it favours a direct answer on the dense view and a reasoned answer on the sparse view, so the model learns that the response mode should follow the evidence.

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.