BRZ911/Thinking-in-Video-Data

Thinking in Video:
Can Video Generators Really Reason About the Real World?

This repository contains the official implementation of Causal-Generative Dual-Judge (CGDJ) for auditing world-model consistency of video generative models — the official codebase of the Thinking in Video paradigm.

🌟 Overview

Thinking in Video is a reasoning paradigm in which a video generative model is used not merely to synthesize pixels, but to simulate, predict, and verify causal thought over time. Convincing rollouts, however, do not necessarily imply causal understanding — they may reflect memorized visual appearance. Existing metrics also separate perceptual fidelity from semantic logic, leaving the reasoning ability of video generators unverified.

To close this gap, we propose the Causal-Generative Dual-Judge (CGDJ) framework, which audits World Model Consistency from two complementary perspectives:

• Explicit Causal Perception — does the generator read a video scenario as a reasoning problem? Tested via spatio-temporal flattened visual question answering.
• Implicit Generative Prediction — does the generator render the causal consequence as a consistent future video? Tested via reference-based generative evaluation.

The framework is built around two key ideas:

• Flatten Temporal Video: a static-image protocol that packs uniformly sampled frames into a single composite image, allowing video generative models to be probed for causal perception with image-only inputs.
• Dual-track judging: an audio+text aligned MLLM judge (Gemini-3-Pro) for explicit causal answers, and a reference-based video quality auditor (also Gemini-3-Pro) for implicit generative consistency.

📄 Paper

Title: Thinking in Video: Can Video Generators Really Reason About the Real World?

📝 Abstract

Recent advances in world models and video generation have given rise to an emerging reasoning paradigm that leverages video generative models to simulate, predict, and reason about real-world dynamics. We redefine this paradigm as Thinking in Video, where video is not merely an output artifact but a medium for constructing, extending, and verifying causal thought. However, this promise remains unverified: convincing rollouts may reflect memorized appearances rather than causal understanding, while existing metrics separate perceptual fidelity from semantic logic. To evaluate whether video generators support such reasoning, we introduce the Causal-Generative Dual-Judge (CGDJ), auditing World Model Consistency from two perspectives. Explicit Causal Perception tests whether a generator reads a video scenario as a reasoning problem through spatio-temporal flattened visual question answering, while Implicit Generative Perception-Prediction Gap evaluates whether it renders the causal consequence as a consistent future video. Applying CGDJ to representative open- and closed-source generators reveals a clear Perception-Prediction Gap: open-source models produce plausible dynamics despite near-zero explicit causal perception, whereas advanced closed-source systems show stronger but still limited alignment between reasoning and generation. Further analysis exposes audio-visual misalignment, where models verbalize correct causal logic more reliably than they render it, challenging the "world simulator" narrative.

🧠 Method

CGDJ is composed of three tightly coupled pieces:

• Causal–Generative Dual-Judge Benchmark — a 1,500-video benchmark (900 from Video-MME + 600 with paired input/gold future videos) covering both explicit and implicit evaluation.
• Flatten Temporal Video — converts a video (and an optional rasterized query) into a single composite image so that image-only or text-to-image-conditioned video generators can be probed on causal understanding.
• Causal–Generative Dual-Judge Evaluation — an automated Gemini-3-Pro-based pipeline that scores both the explicit causal answer and the implicit generative rollout.

1. 🖼️ Flatten Temporal Video

Because most current video generative models only accept static image inputs, we compress each video into a single composite image I_composite ∈ ℝ^(1280×720×3):

• Temporal Grid Construction — uniformly sample N = 70 frames and tile them into a 7 × 10 spatial matrix.
• Semantic Rendering — rasterize the textual query into a dense pixel-space strip and place it in the upper visual field.
• Vertical Integration — concatenate the semantic strip and the temporal grid, then resize to 1280 × 720.

For implicit generative evaluation, a lighter motion-anchor variant extracts N = 7 keyframes from the input video and concatenates them horizontally into a "visual arrow of time" I_motion that encodes the directional motion prior.

2. 🧪 Explicit Causal Perception

For each Video-MME video, a multimodal judge receives:

1. The generator's video output,
2. Whisper-large-v2 transcription of the audio track,
3. The original question, options, and ground-truth answer,

and classifies the response as Correct / Incorrect for spatio-temporal causal reasoning.

3. 🎬 Implicit Generative Prediction

For each of the 600 causal videos (300 Natural Sciences + 300 Sociology & Humanities), the generator is asked to roll out the post-event future, and a Gemini-3-Pro Video Quality Auditor scores the result in [0.0, 1.0] along three axes:

• Semantic Alignment — object / action correctness
• Reference Consistency — logical flow vs. gold video
• Physical Validity — absence of flickering or physics violations

📊 Experimental Results

We audit both open- and closed-source generators on the CGDJ benchmark. The headline finding is a clear Perception-Prediction Gap:

• Open-source models (Wan-2.2-14B, HunyuanVideo-1.5) collapse under flattened causal reasoning (near-zero explicit perception) yet still produce moderately plausible causal continuations.
• Closed-source models (Sora-2, Veo-3.1) show stronger but still limited alignment between causal reasoning and video rollout.
• Audio-visual misalignment — models articulate correct causal logic more reliably than they render it, challenging the "world simulator" narrative.

📁 Repository Structure

Thinking-in-Video/
├── Perception/                         # Explicit Causal Perception track
│   ├── perception_data.jsonl           # Input data (imageID/image_path/question/options/answer)
│   ├── 01_generate_video_veo3.py       # Stage 1: Veo 3.1 image-to-video
│   ├── 02_transcribe_audio_whisper.py  # Stage 2: Whisper-large-v2 audio transcription
│   ├── 03_judge_answer_gemini3.py      # Stage 3: Gemini-3-Pro answer judging
│   ├── outputs/                        # Runtime artifacts
│   └── README.md
├── Prediction/                         # Implicit Generative Prediction track
│   ├── prediction_data.jsonl           # Input data (data_id/domain/sub_category/image_path/input_video_path/output_video_path)
│   ├── 01_generate_video_veo3.py       # Stage 1: Veo 3.1 image-to-video (predict the second half)
│   ├── 02_judge_video_gemini3.py       # Stage 2: Gemini-3-Pro video quality scoring
│   ├── outputs/                        # Runtime artifacts
│   └── README.md
├── figures/                            # Figures, icons, framework/teaser images
└── README.md

🚀 Getting Started

1. 🐍 Install the Environment

conda create -n thinkvideo python=3.11 -y
conda activate thinkvideo
pip install -r requirements.txt

The judging pipeline uses Gemini-3-Pro as the multimodal judge and Whisper-large-v2 for audio transcription. Configure the corresponding API credentials in the scripts before running.

🏋️ Running the CGDJ Evaluation

The judging pipeline is split into two tracks that mirror the two CGDJ modules: Perception/ for Explicit Causal Perception and Prediction/ for Implicit Generative Prediction. Each track's scripts follow the same NN_<action>_<object>_<model>.py naming convention, so their stages line up 1:1.

🧪 Explicit Track — Perception/

cd Perception
export GOOGLE_API_KEY="..."

python 01_generate_video_veo3.py           # Stage 1: Veo 3.1 image-to-video
python 02_transcribe_audio_whisper.py      # Stage 2: Whisper-large-v2 transcription
python 03_judge_answer_gemini3.py          # Stage 3: Gemini-3-Pro answer judging

Produces outputs/03_result_judged_gemini3.jsonl with a judge field (yes / no / None) per item. See Perception/README.md for full details.

🎬 Implicit Track — Prediction/

cd Prediction
export GOOGLE_API_KEY="..."

python 01_generate_video_veo3.py           # Stage 1: Veo 3.1 predicts the second half
python 02_judge_video_gemini3.py           # Stage 2: Gemini-3-Pro video quality scoring

Produces outputs/02_result_scored_gemini3.jsonl with a score field in [0.0, 1.0] per item. See Prediction/README.md for full details.

🧪 Evaluating New Generators

To evaluate a new video generator with CGDJ:

1. Run the generator on every image referenced in Perception/perception_data.jsonl (explicit track) and Prediction/prediction_data.jsonl (implicit track).
2. Point each track's Stage 1 script at your generator's outputs (or save the generated videos under a new outputs/<your_model>/ directory).
3. Run the remaining stages of each track's pipeline against that directory.
4. Compare the resulting judge (explicit) and score (implicit) fields across models to compute the Perception-Prediction Gap.

📚 Citation

Please open GitHub issues or email Yongheng Zhang if you have any questions or suggestions. If you find this work useful, please cite:

@misc{zhang2026thinkingvideovideogenerators,
      title={Thinking in Video: Can Video Generators Really Reason About the Real World?}, 
      author={Yongheng Zhang and Guang Yang and Ruihan Hou and Qiguang Chen and Ziang Liu and Xiaolong Liu and Manman Zhang and Yanchao Hao and Zheng Wei and Hao Wu and Libo Qin and Peishan Dai and Yinghui Li and Di Yin and Xing Sun},
      year={2026},
      eprint={2607.17523},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2607.17523}, 
}