| --- |
| language: |
| - en |
| license: other |
| size_categories: |
| - 1K<n<10K |
| task_categories: |
| - video-text-to-text |
| - visual-question-answering |
| tags: |
| - video-understanding |
| - reinforcement-learning |
| - adaptive-reasoning |
| configs: |
| - config_name: default |
| data_files: |
| - split: train |
| path: train.parquet |
| --- |
| |
| # EVAThink-Dataset-Stage1 |
|
|
| ## Paper & Code |
|
|
| - Paper: [EVAThink: Evidence Sufficiency-Guided Training for Adaptive Thinking in Video Understanding](https://arxiv.org/abs/2611.13907) |
| - Code: [GitHub repository](https://github.com/ChangtiWu/EVAThink) |
|
|
| Training data for **stage 1** of the two-stage reinforcement learning that produces |
| [EVAThink-Qwen3](https://huggingface.co/MaplesWCT/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](https://huggingface.co/datasets/MaplesWCT/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 |
|
|
| ```bash |
| 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 |
| ``` |
|
|
| ```python |
| import pyarrow.parquet as pq |
| |
| rows = pq.read_table("train.parquet").to_pylist() |
| r = rows[0] |
| r["prompt"][0]["content"] # "<video> |
| " + 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](https://github.com/volcengine/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. |
