File size: 6,946 Bytes
1bb0b8a 30f46a4 1bb0b8a 30f46a4 1bb0b8a 30f46a4 1bb0b8a 30f46a4 1bb0b8a 30f46a4 1bb0b8a 30f46a4 1bb0b8a 30f46a4 1bb0b8a 30f46a4 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | ---
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. |