README.md

---
pretty_name: OneSearch-Video-Bench
language:
- en
task_categories:
- visual-question-answering
tags:
- benchmark
- visual-search
- video
size_categories:
- n<1K
configs:
- config_name: default
  data_files:
  - split: test
    path: test.jsonl
---

# OneSearch-Video

OneSearch-Video contains 307 visual question-answer pairs over 293 silent videos.
The distributed MP4 files play at **1 FPS**. Each playback second represents one
ordered frame slot in the benchmark input. This is the playback rate of the
sampled sequence, not a claim that the source footage was sampled once per second.

## Files

```text
README.md
prepare.py
extract_frames.py
test.jsonl
media.jsonl
frames.jsonl
alignment.json
media/
  0000.mp4
  ...
runtime/frames/
  0000/frame_000.png
  ...
```

Videos are distributed in `video-00001.zip`. Original-resolution tool frames
are distributed separately in `video-frames-*.zip`. Extract both the video
archive and every frame archive into this directory, preserving their paths.
Each archive is at most 10 GB (10,000,000,000 bytes). The PNGs preserve the
annotation images exactly, including their original resolution and file bytes.
They are not decoded from the smaller MP4s.

From the distribution directory:

```bash
unzip video-00001.zip
for archive in video-frames-*.zip; do unzip "$archive"; done
```

`test.jsonl` has one record per question:

| Field | Meaning |
| --- | --- |
| `id` | Stable sample ID, represented as a string |
| `question` | Question given to the model |
| `answer` | Reference answer for evaluation; not an actor input |
| `video` | MP4 path relative to this dataset directory |
| `fps` | Playback rate, always `1` |
| `n_frames` | Number of frames in the released MP4 |
| `structure` | Question structure |
| `difficulty` | Difficulty label |
| `num_hops` | Annotated reasoning hop count |
| `knowledge_domain` | Knowledge category |

Multiple questions may reference the same video. `media.jsonl` contains
one entry per unique MP4 with its relative path, byte size, frame count,
playback rate and encoded dimensions. `frames.jsonl` maps each video path
to its ordered original-resolution PNGs, with relative paths, frame indices,
byte sizes and image dimensions. `alignment.json`
records the scope and results of the frame correspondence checks.

The checks cover all 307 QA records, 565 annotated target-frame references,
293 videos and 37,354 PNGs. Annotation frame indices match their source-frame
mapping. Encoding the ordered reference PNGs reproduces 253 MP4s byte for byte;
the other 40 videos pass per-frame visual correspondence checks against all
candidate frame slots. See `alignment.json` for the comparison method and
tolerances. All distributed PNGs are byte-identical to their reference files.

## Optional MP4 frame extraction

The benchmark uses the distributed original-resolution PNGs. For inspection,
`extract_frames.py` can also decode frames from the MP4 files:

```bash
python extract_frames.py
python extract_frames.py --video media/0000.mp4
python extract_frames.py --output-dir ./decoded_frames --workers 4
```

These diagnostic frames go to `runtime/decoded_frames/<video_id>/` by default.
The script preserves the MP4 frame order and encoded dimensions, which can be
smaller than the benchmark PNG dimensions. It refuses to write to the official
`runtime/frames/` tree. MP4-decoded images must not replace the original-resolution
benchmark images. No API key or network access is needed for extraction.

## Prepare inference inputs

Requirements: Python 3.9 or newer, `ffmpeg` and `ffprobe` on `PATH`.
The loader uses the Python standard library and makes no model or judge calls.

After extracting both kinds of media archives, check all videos and PNGs:

```bash
python prepare.py --verify-only
```

Expose this entire dataset directory through an HTTP(S) media server reachable
by the inference backend. Set `MEDIA_BASE_URL` to its URL, then run:

```bash
python prepare.py --media-base-url "$MEDIA_BASE_URL"
```

The loader checks each MP4 byte size, stream layout, playback rate and frame
count, then checks the existing original-resolution PNG filenames, sequence,
byte sizes and dimensions against `frames.jsonl`. It does not decode, resize, replace or
regenerate the benchmark images. Missing or mismatched frame files cause an
error instead of falling back to MP4 decoding.

The generated files are:

- `runtime/video.csv`: `index,question,answer` for inference and evaluation.
- `runtime/video_manifest.jsonl`: the video and ordered frame URLs for tools.
The media server must also expose `runtime/frames/`, populated by extracting
the frame archives. The loader does not generate these PNGs.

For every sample, `case_id` equals its `id`; `n_frames` equals the number of
`frame_urls`; `frame_indices` is `0..n_frames-1`; `grid_fps` is `1.0`;
`duration` is `n_frames` playback seconds. Frame slot `i` refers to the frame
at playback time `i` seconds. A time span `[a, b)` uses slots `a` through `b-1`.
The manifest contains no answers, annotations or source-video metadata.

From the OneSearch-VL code repository, with `DATA_ROOT` pointing to this dataset:

```bash
python onesearch_vl/run_infer_video.py \
  --model 8b --checkpoint /models/your-checkpoint \
  --csv "$DATA_ROOT/runtime/video.csv" \
  --manifest "$DATA_ROOT/runtime/video_manifest.jsonl" \
  --output-dir outputs/onesearch_video

bash onesearch_vl/run_eval.sh video \
  --csv "$DATA_ROOT/runtime/video.csv" \
  --traj_dir outputs/onesearch_video
```

Configure inference, search and evaluation credentials in the code repository
before running those commands. Only the question and visual media are actor
inputs. Reference answers are used by the evaluator. Audio, source timestamps,
source URLs and video metadata are not supplied as evidence.

The MP4 overview and the PNG tool inputs represent the same ordered frame
sequence. The MP4 is scaled and compressed; the PNGs retain the annotation
images' resolution for object crops and visual search. Frame slot `i` in the
video maps to `frame_i` in the PNG sequence. A correspondence check does not
establish the semantic correctness or answerability of every QA sample.
No model evaluation results are included in this package.