Datasets:

CSU-JPG
/

LabInstruct

configs:
  - config_name: specs
    default: true
    data_files:
      - split: full
        path: viewer_data/specs.parquet
  - config_name: checklists
    data_files:
      - split: full
        path: viewer_data/checklists.parquet
  - config_name: qa_items
    data_files:
      - split: full
        path: viewer_data/qa_items.parquet
  - config_name: video_sources
    data_files:
      - split: full
        path: viewer_data/video_sources.parquet
  - config_name: source_annotations
    data_files:
      - split: full
        path: viewer_data/source_annotations.parquet
  - config_name: rules
    data_files:
      - split: full
        path: viewer_data/rules.parquet

LabInstruct: Benchmarking Situated Instructional Video Generation for Lab Procedures

🌐 Homepage | 👉 Dataset | 📄 Paper (coming soon) | 💻 Code | 🏆 Leaderboard

ℹ️ This repository only hosts the LabInstruct annotation data: structured annotations and source-video links only. Videos, clips, and first frames are not included here; rebuild them with the LabInstruct code repository.

📢 Updates

[2026-09] LabInstruct is online!

📝 TODO

Release the annotation data: 204 task specifications, 204 QA checklists, 81 source clip-boundary annotations, and source-video links.
Release the code: data preparation, video generation, and evaluation harness.

📜 Abstract

Self-driving laboratories (SDLs) aim to automate the full experimental loop, from scientific decision-making to physical execution. Ideally, AI-generated plans could be carried out directly by robotic systems, but reliable automation remains difficult in complex, open-world laboratory environments, where experiments often involve fine-grained manipulation, long-horizon procedures, and substantial variation across tasks and setups. Humans therefore remain an important execution interface between AI-generated plans and physical experiments, creating a need for clear and effective human-facing experimental guidance. Because laboratory procedures are inherently visual, spatial, and dynamic, video is particularly well suited to communicating apparatus configurations, manipulation actions, temporal dependencies, and state changes. Recent advances in video generation now make it possible to synthesize experimental demonstrations directly from an initial workspace image and a natural-language instruction. However, whether such models can reliably communicate real laboratory procedures has not been systematically studied. We introduce LabInstruct, a benchmark for situated instructional video generation in real laboratories. LabInstruct contains 204 tasks across 5 scientific disciplines, with real reference executions and structured annotations of objects, actions, contacts, and state transitions. Evaluating 8 frontier image-to-video models, we find that visually plausible generations frequently remain procedurally incorrect, revealing a substantial gap between visual realism and the reliability required for experimental instruction.

🌟 Project Overview

Overview of the LabInstruct benchmark

Figure 1. LabInstruct evaluates generated laboratory videos for procedural correctness beyond visual plausibility.

🚀 Setup

ℹ️ The setup and usage below refer to the LabInstruct code repository. This repository contains only the files under data/ (see Data Files), the README figures, and the license; bench/ and scripts/ live in the code repository.

1. Environment setup

Python 3.10 or newer is required. Install ffmpeg and ffprobe for media reconstruction and video evaluation.

python -m venv .venv
source .venv/bin/activate
pip install -e .

Optional dependencies:

pip install -e ".[diffusers]"
pip install -e ".[qa]"

2. Prepare benchmark data

Place legally obtained source videos under data/source_videos/, using the source_video_id names in data/video_sources.csv.

python scripts/prepare_data.py --check
python scripts/prepare_data.py --clips --first-frames
python scripts/specs_to_tasks.py

3. Generate videos

Configure model environments and checkpoints in bench/models.yaml, then run:

python -m bench.cli gen \
  --run exp1 \
  --models wan2.2,ltx2.3,minimax-h3 \
  --gpus 0,1,2,3

4. Evaluate videos

export JUDGE_API_BASE_URL="https://your-endpoint.example/v1"
export GPT_API_TOKEN="your-token"

python scripts/judge_videos_gpt.py --model-name all --fps 4

🗂 Repository Structure

.
├── data/
│   ├── video_sources.csv       source-video provenance and URLs
│   ├── specs/                  structured task specifications (204 tasks)
│   ├── checklists/             frozen QA checklists (204 tasks)
│   ├── source_annotations/     source clip boundaries (81 source videos)
│   └── rules/                  annotation and evaluation prompts
├── assets/                     figures used by this README
└── LICENSE                     Apache License 2.0

This repository releases links and annotations only. The third-party source videos, extracted clips, and first frames are not included. Download the source videos from the URLs in data/video_sources.csv under their original terms, then rebuild clips and first frames with scripts/prepare_data.py in the LabInstruct code repository.

📁 Data Files

This section explains what every file under data/ is for. All annotation files are UTF-8 JSON or plain text; data/video_sources.csv is the only file that references the source videos.

`data/video_sources.csv` — source-video provenance

One row per source video (81 in total: 61 bilibili, 15 FineBio, 3 ExpVid, 2 YouTube). Columns:

Column	Description
`source_video_id`	3-digit source video id (e.g. `001`). Matches the annotation file in `data/source_annotations/` and the `source_video_id` names used by `scripts/prepare_data.py` in the code repository.
`source_url`	Link to the original video. Use it to download the source video legally under its original terms; the video itself is not in this repository.
`platform`	Hosting platform / source dataset of the video.
`n_task_clips`	Number of task clips cut from this source video (sums to 204 across all rows).
`note`	Free-form notes.

`data/specs/` — task specifications (204 JSON files)

One file per benchmark task, named {index}_{split}_{source_id}_{discipline}_spec.json (e.g. 001_L1_001_agronomy_spec.json). These are the core structured annotations of each laboratory procedure:

Field	Description
`task_id`	Unique task id, identical to the file stem.
`split`	Task level: `L1` (101 tasks) = a single atomic step (1–3 closely related actions); `L2` (103 tasks) = a complete short subprocedure with an ordered action sequence.
`domain`	Procedure domain, one or more of `solid_handling`, `liquid_handling`, `measurement`, `instrument_operations`, `container_operations`, `heating_cooling`, `filtration_separation` (multiple values joined by `
`discipline`	Scientific discipline: `agronomy`, `biology`, `chemistry`, `materials_science`, or `physics`.
`title` / `description`	Short title and a plain-language description of the procedure.
`initial_image`	Relative path to the task's first frame, which serves as the image input for video generation. The frame itself is not included; rebuild it with `prepare_data.py --first-frames` in the code repository.
`scene`	Annotated scene: `objects` (each with `id`, `name`, `contents`, `material`), `spatial_relations` (natural-language spatial descriptions), and `environment` (e.g. `indoor_laboratory`).
`action_sequence`	Ordered action steps; each step has `action`, `target_object`, `contact` (e.g. `hand_tool`, `tool_object`), and `state_transition` (`from` / `to` states).
`prompt_for_gen`	The natural-language instruction used as the text prompt for video generation.
`difficulty_features`	Quantitative difficulty flags: `number_of_objects`, `number_of_action_steps`, and boolean requirements (`requires_liquid_handling`, `requires_tool_manipulation`, `requires_fine_motor_control`, `requires_transparent_object_reasoning`, `requires_color_tracking`, `requires_volume_change_detection`, `requires_spatial_memory`, `requires_sequential_ordering`).
`viewpoint`	Recorded viewpoint: `first_person` (67 tasks) or `nearby_observer` (137 tasks).

`data/checklists/` — QA checklists (204 JSON files)

One file per task, named {task_id}_qa.json. Each checklist is a frozen set of yes/no questions for judging whether a generated video executes the task correctly. The evaluation prompt data/rules/vlm_judge.txt consumes these checklists, and the same questions are what raters answered in the human study.

Field	Description
`task_id` / `task_level` / `source_spec`	The task this checklist belongs to and the spec file it was generated from.
`items[].qa_id`	Question id within the checklist.
`items[].dimension`	Evaluation dimension, one of six: `Action Fidelity`, `Object Consistency`, `State Correctness`, `Physical Plausibility`, `Visual Safety`, `Scene Consistency`.
`items[].importance`	Question weight: `critical` or `standard`.
`items[].question` / `items[].question_zh`	The question in English and in Chinese.

Across the 204 checklists there are 3,229 questions in total: 1,299 Action Fidelity, 567 Object Consistency, 448 State Correctness, 371 Physical Plausibility, 305 Visual Safety, and 239 Scene Consistency.

`data/source_annotations/` — source clip boundaries (81 CSV files)

One file per source video, named {source_video_id}.txt. Columns: start_sec, end_sec, level. Each row marks one task clip inside the source video: its start/end time in seconds and the task level (L1/L2) of that clip. scripts/prepare_data.py --clips in the code repository uses these boundaries to cut data/video_clips/ from the downloaded source videos. The clips themselves are not included.

`data/rules/` — annotation and evaluation prompts (4 files)

Plain-text prompts that reproduce the annotation and evaluation pipeline:

File	Purpose
`L1_vlm_annotation.txt`	VLM prompt for drafting an L1 spec (atomic-action annotation) from a video clip.
`L2_vlm_annotation.txt`	VLM prompt for drafting an L2 spec (short-subprocedure annotation) from a video clip.
`qa_generation.txt`	Prompt for generating the task-specific QA checklist from a spec.
`vlm_judge.txt`	Prompt for judging a generated video against the frozen checklist.

These prompts are written to produce structured drafts for human verification.

🏆 Leaderboard

Pooled Overall is evaluated by GPT-5.6 Sol at 4 FPS. Higher is better; † marks commercial models.

Rank	Model	Type	Organization	Pooled Overall
1	MiniMax H3	Open weight	MiniMax	46.3
2	Seedance 2.0 †	Commercial	ByteDance	45.1
3	Wan 3.0 †	Commercial	Alibaba	44.4
4	Wan 2.2-I2V-A14B	Open weight	Alibaba	25.9
5	Cosmos3 Super	Open weight	NVIDIA	22.8
6	LTX 2.3	Open weight	Lightricks	22.1
7	LingBot Video	Open weight	Robbyant	19.5
8	Cosmos3 Nano	Open weight	NVIDIA	19.4

🎓 BibTeX

If you find our work helpful, please consider citing it:

@misc{fu2026labinstruct,
  title         = {LabInstruct: Benchmarking Situated Instructional Video Generation for Lab Procedures},
  author        = {Yuming Fu and Weijia Wu and Jing Chen and Jiahao Tang and Feifei Chen and Hongyu Zhu and Xin Jin and Alex Jinpeng Wang},
  year          = {2026},
  eprint        = {XXXX.XXXXX},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CV},
  url           = {https://arxiv.org/abs/XXXX.XXXXX}

📧 Contact

For questions, please open an issue in this repository or email Yuming Fu at yumingfu@csu.edu.cn.

🙏 Acknowledgements

We thank the creators of the source videos and the authors of FineBio, ExpVid, and the evaluated video-generation models for their work.