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.