---
license: other
task_categories:
  - video-text-to-text
  - visual-question-answering
language:
  - en
tags:
  - video-understanding
  - reinforcement-learning
  - adaptive-reasoning
size_categories:
  - 1K<n<10K
configs:
  - config_name: default
    data_files:
      - split: train
        path: train.parquet
---

# EVAThink-Dataset-Stage1

<!-- TODO(author): paper title / arXiv link, code repo link -->
<!-- TODO(author): confirm the license field. The frames come from third-party video datasets (see "Source data"). -->

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>\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](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.