File size: 6,722 Bytes
ff86bcd f2f3a27 ff86bcd f2f3a27 ff86bcd f2f3a27 ff86bcd f2f3a27 ff86bcd f2f3a27 ff86bcd f2f3a27 ff86bcd f2f3a27 ff86bcd f2f3a27 | 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 | ---
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-Stage2
[Paper](https://huggingface.co/papers/2611.13907) · [Code](https://github.com/ChangtiWu/EVAThink)
Training data for **stage 2** 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 **remaining gold pairs**: every gold pair that is not in the Stage 1 strict set. The other stage is [EVAThink-Dataset-Stage1](https://huggingface.co/datasets/MaplesWCT/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
```bash
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
```
```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 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. |