add video eval script

.gitignore

@@ -0,0 +1,209 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+.DS_Store

README.md

@@ -4,7 +4,7 @@
 **FCMBench** is a multimodal benchmark for credit-risk–oriented workflows. It aims to provide a standard playground to promote collaborative development between academia and industry and provides standardized datasets, prompts, and evaluation scripts across multiple tracks (image, video, speech, agents, etc.)
 
 <p align="center">
-💻 <a href="https://github.com/QFIN-tech/FCMBench/tree/main"><b>GitHub</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🤖 <a href="https://modelscope.cn/datasets/QFIN/FCMBench-Data"><b>ModelScope</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2601.00150"><b>FCMBench Paper</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2604.25186"><b>FCMBench-Video Paper</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🏆 <a href="https://qfin-tech.github.io/FCMBench"><b>Leaderboard</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🌐 <a href="./README_cn.md"><b>简体中文</b></a>
+🤗 <a href="https://huggingface.co/datasets/QFIN/FCMBench-Data"><b>Hugging Face</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🤖 <a href="https://modelscope.cn/datasets/QFIN/FCMBench-Data"><b>ModelScope</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2601.00150"><b>FCMBench Paper</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2604.25186"><b>FCMBench-Video Paper</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🏆 <a href="https://qfin-tech.github.io/FCMBench"><b>Leaderboard</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🌐 <a href="./README_cn.md"><b>简体中文</b></a>
 </p>
 
 ## 🔥 News
@@ -23,7 +23,7 @@
 | Entry | Inputs | Outputs | Evaluation Script | Leaderboard | Paper | Sample Data |
 |---|---|---|---|---|---|---|
 | [Vision-Language Track](vision_language) | document images + text prompts (JSONL, one sample per line) | text responses (JSONL, one sample per line) | [evaluation.py](vision_language/evaluation.py) | [Leaderboard](https://qfin-tech.github.io/FCMBench) | [arXiv 2601.00150](https://arxiv.org/abs/2601.00150) | [Examples](https://qfin-tech.github.io/FCMBench/Examples.html) |
-| [Video Understanding Track](video_understanding) | document videos + text prompts (JSONL) | text responses (JSONL) | *(TBD)* | *(TBD)* | [arXiv 2604.25186](https://arxiv.org/abs/2604.25186) | *(TBD)* |
+| [Video Understanding Track](video_understanding) | document videos + text prompts (JSONL) | text responses (JSONL) | [benchmark_eval.py](video_understanding/benchmark_eval.py) | via [submission](video_understanding/README.md#leaderboard) | [arXiv 2604.25186](https://arxiv.org/abs/2604.25186) | see [README](video_understanding/README.md) |
 
 ---
 
@@ -51,7 +51,7 @@ Access will be granted on a case-by-case basis.
 Document-video intelligence benchmark covering document perception, temporal grounding, and evidence-grounded reasoning under realistic handheld capture conditions. Built from 495 captured atomic videos composed into 1,200 long-form videos (20s/40s/60s duration tiers) with 11,322 expert-annotated QA instances across 28 document types in bilingual Chinese/English settings. See the [paper](https://arxiv.org/abs/2604.25186) for full benchmark details and evaluation results on nine Video-MLLMs.
 
 #### Sample Data
-*(TBD)*
+Please refer to the [Video Understanding track README](video_understanding/README.md) for the full data composition, instruction file descriptions, and quickstart guide. A stratified 10% subset with ground-truth (`FCMBench-Video_v1.0_small.jsonl`) is available for self-evaluation.
 
 #### Reference Model Demo
 *(TBD)*

README_cn.md

@@ -4,7 +4,7 @@
 **FCMBench** 是一个面向信贷风控工作流的多模态基准测试（benchmark）。它旨在提供一个标准化的"试验场"，促进学术界与产业界的协同开发，并在多个赛道（图像、视频、语音、智能体等）上提供标准化的数据集、提示词（prompts）与评测脚本。
 
 <p align="center">
-💻 <a href="https://github.com/QFIN-tech/FCMBench/tree/main"><b>GitHub</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🤖 <a href="https://modelscope.cn/datasets/QFIN/FCMBench-Data"><b>ModelScope</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2601.00150"><b>FCMBench 论文</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2604.25186"><b>FCMBench-Video 论文</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🏆 <a href="https://qfin-tech.github.io/FCMBench"><b>排行榜</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🌐 <a href="./README.md"><b>English</b></a>
+🤗 <a href="https://huggingface.co/datasets/QFIN/FCMBench-Data"><b>Hugging Face</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🤖 <a href="https://modelscope.cn/datasets/QFIN/FCMBench-Data"><b>ModelScope</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2601.00150"><b>FCMBench 论文</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;📑 <a href="https://arxiv.org/abs/2604.25186"><b>FCMBench-Video 论文</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🏆 <a href="https://qfin-tech.github.io/FCMBench"><b>排行榜</b></a>&nbsp;&nbsp; | &nbsp;&nbsp;🌐 <a href="./README.md"><b>English</b></a>
 </p>
 
 ## 🔥 新闻
@@ -23,7 +23,7 @@
 | 赛道入口 | 输入 | 输出 | 评测脚本 | 排行榜 | 论文 | 样例数据 |
 |---|---|---|---|---|---|---|
 | [Vision-Language Track](vision_language) | 文档图像 + 文本指令（JSONL，每行一个样本） | 文本响应（JSONL，每行一个样本） | [evaluation.py](vision_language/evaluation.py) | [排行榜](https://qfin-tech.github.io/FCMBench) | [arXiv 2601.00150](https://arxiv.org/abs/2601.00150) | [示例页](https://qfin-tech.github.io/FCMBench/Examples.html) |
-| [Video Understanding Track](video_understanding) | 文档视频 + 文本指令（JSONL） | 文本响应（JSONL） | *(待定)* | *(待定)* | [arXiv 2604.25186](https://arxiv.org/abs/2604.25186) | *(待定)* |
+| [Video Understanding Track](video_understanding) | 文档视频 + 文本指令（JSONL） | 文本响应（JSONL） | [benchmark_eval.py](video_understanding/benchmark_eval.py) | 通过[提交](video_understanding/README_cn.md#排行榜)参与 | [arXiv 2604.25186](https://arxiv.org/abs/2604.25186) | 详见 [README](video_understanding/README_cn.md) |
 
 ---
 
@@ -51,7 +51,7 @@
 面向文档视频智能的基准测试，覆盖真实手持拍摄条件下的文档感知、时序定位与证据推理能力。基于 495 段实拍原子视频构建，组合为 1,200 段长视频（20s/40s/60s 时长区间），配套 11,322 条专家标注的问答实例，覆盖 28 种文档类型（中英双语）。详见[论文](https://arxiv.org/abs/2604.25186)了解完整基准设计和 9 款 Video-MLLM 的评测结果。
 
 #### 样例数据
-*(待定)*
+请参阅[视频理解赛道 README](video_understanding/README_cn.md) 了解完整的数据组成、指令文件说明和快速开始指南。提供一个含真值标注的分层 10% 子集（`FCMBench-Video_v1.0_small.jsonl`）用于自测。
 
 #### 参考模型 Demo
 *(待定)*

video_understanding/README.md

@@ -0,0 +1,171 @@
+# FCMBench — Video Understanding Track Evaluation
+
+[🌐 简体中文](README_cn.md)
+
+This repository provides evaluation scripts for **FCMBench-Video** (Video Understanding track).
+The workflow is:
+
+1) prepare the video data and instruction file
+2) run inference with your model to produce a JSONL prediction file
+3) evaluate predictions against the provided ground-truth (or submit results for leaderboard ranking)
+
+---
+
+## Test Data Composition
+
+FCMBench-Video v1.0 contains **11,322** video–question pairs across 7 tasks and 2 language settings.
+
+Each video is a handheld recording of credit-review documents (2—4 per clip) at 20s / 40s / 60s, with 3 takes per duration. The `1,200` videos (≈135 person-scenarios) are organized as:
+
+```
+FCMBench-Video_v1.0_Videos/
+└── video/
+    ├── Construction/          # CN original videos (15 persons × 9 = 135 clips)
+    ├── Construction-en-US/    # EN original videos (30 persons × 9 = 265 clips)
+    ├── VPI-cn/                # CN videos with visual prompt injection (135 clips)
+    ├── VPI-cot-cn/            # CN VPI + Chain-of-Thought (135 clips)
+    ├── VPI-en-US/             # EN VPI (265 clips)
+    └── VPI-cot-en-US/         # EN VPI + CoT (265 clips)
+```
+
+### Instruction files
+
+| File | Description | Has GT | Use case |
+|------|-------------|--------|----------|
+| `FCMBench-Video_v1.0_full.jsonl` | Full 11,322 samples (CN + EN merged) | ✗ | Public release; run inference |
+| `FCMBench-Video_v1.0_small.jsonl` | Stratified 10% sample (~1,135) | ✓ | Quick self-evaluation / sanity check |
+| `FCMBench-Video_v1.0_full-gt.jsonl` | Full 11,322 samples | ✓ | Internal reference (not distributed) |
+
+**Tasks** (7 types across perception & reasoning):
+
+| Category | Task | CN (zh_zh / zh_en) | EN (en_en) |
+|----------|------|---------------------|------------|
+| perception | classification | 1,350 | 1,325 |
+| perception | counting | 1,350 | 1,325 |
+| perception | temporal_grounding | 1,350 | 1,325 |
+| reasoning | VPI | 540 | 530 |
+| reasoning | VPI-CoT | 540 | 530 |
+| reasoning | CDV | 270 | — |
+| reasoning | EGS | 560 | 327 |
+| **Total** | | **5,960** | **5,362** |
+
+---
+
+## Environments
+
+- Python 3.10+
+- `uv` is recommended for dependency management
+- Or use `pip` if you prefer a traditional virtual environment
+
+```bash
+# uv
+uv sync
+
+# pip
+pip install openai tqdm json-repair
+```
+
+---
+
+## Quickstart
+
+### 1) Prepare video data
+
+```bash
+unzip FCMBench-Video_v1.0_Videos.zip
+```
+
+The unzipped tree will look like:
+
+```
+FCMBench-Video_v1.0_Videos/
+└── video/
+    ├── Construction/
+    ├── Construction-en-US/
+    ├── VPI-cn/
+    ├── VPI-cot-cn/
+    ├── VPI-en-US/
+    └── VPI-cot-en-US/
+```
+
+The instruction JSONL files use `video_prefix` + `video_path` fields (e.g.
+`"video_prefix": "Construction", "video_path": "yangyimiao/yangyimiao_20s_1.mp4"`),
+so point `--video_root` to the `FCMBench-Video_v1.0_Videos/` directory.
+
+### 2) Run inference
+
+Use the **single** instruction file `FCMBench-Video_v1.0_full.jsonl` (no ground-truth).
+Both the Python script and the shell pipeline accept a `--input_file` argument.
+
+```bash
+bash benchmark_pipeline.sh \
+  --input_file FCMBench-Video_v1.0_full.jsonl \
+  --output_dir ./results \
+  --video_root ./FCMBench-Video_v1.0_Videos \
+  --model <model_name> \
+  --base_url <base_url>
+```
+
+Or call `benchmark_infer.py` directly:
+
+```bash
+python benchmark_infer.py \
+  --input_file FCMBench-Video_v1.0_full.jsonl \
+  --output_dir ./results \
+  --video_root ./FCMBench-Video_v1.0_Videos \
+  --model <model_name> \
+  --base_url <base_url>
+```
+
+> **Resume support:** add `--resume` to skip task IDs already present in the output file.
+
+The inference script writes one result file:
+```
+results/FCMBench-Video_v1.0_full_<model>_<run_id>.jsonl
+```
+
+Each output line is the original instruction line plus a `"response"` field
+containing the model's raw reply.
+
+### 3) Evaluate predictions
+
+```bash
+python benchmark_eval.py --result_dir ./results
+```
+
+The evaluator expects **exactly one** `.jsonl` file in `--result_dir`. It prints
+per-task metrics (by zh/en subset and by video duration) to stdout and also writes:
+
+- `results/eval_reports/FCMBench-Video_v1.0_full_<model>_<run_id>.txt` — per-task breakdown
+- `results/eval_reports/benchmark_overall.txt` —  benchmark-level overall score
+
+### Self-evaluation with small.jsonl
+
+For a quick sanity check, use `FCMBench-Video_v1.0_small.jsonl` (~1,135 stratified
+samples with ground-truth). Run inference on it (same workflow as above), then
+evaluate — metrics are computed against the included GT.
+
+---
+
+## Leaderboard
+
+### Self-assessment (small.jsonl)
+
+Researchers can run inference on `FCMBench-Video_v1.0_small.jsonl` and compute
+evaluation metrics locally using `benchmark_eval.py`. This gives a reliable
+approximation of model performance across all 7 tasks and both language subsets.
+
+### Official leaderboard submission
+
+To have your model ranked on the **FCMBench-Video leaderboard**:
+
+1. Run inference on **`FCMBench-Video_v1.0_full.jsonl`** with your model.
+2. Save predictions to a single JSONL file (the `benchmark_infer.py` output format
+   is the expected format — one JSON object per line with `task_id` and `response`).
+3. Email the result file to **yangyehuisw@126.com** with the following information:
+   - Model name / version
+   - Inference framework (or API) and key settings (e.g., temperature, max tokens)
+   - Any special post-processing applied (if applicable)
+
+After validation, we will compute the official metrics on the hidden ground-truth
+(`FCMBench-Video_v1.0_full-gt.jsonl`) and update the leaderboard.

video_understanding/README_cn.md

@@ -0,0 +1,165 @@
+# FCMBench — 视频理解赛道评测
+
+[🌐 English](README.md)
+
+本仓库提供 **FCMBench-Video**（视频理解赛道）的评测脚本。
+整体流程为：
+
+1) 准备视频数据和指令文件
+2) 使用你的模型进行推理，生成 JSONL 预测文件
+3) 依据提供的真值标注进行评估（或提交结果参与排行榜排名）
+
+---
+
+## 测试数据组成
+
+FCMBench-Video v1.0 包含 **11,322** 组视频-问题对，覆盖 7 个任务和 2 个语言设置。
+
+每个视频为信用审核文档的手持拍摄片段（每段 2-4 份文件），设置 20s / 40s / 60s 三种时长，每种时长拍摄 3 次。共 `1,200` 个视频（约 135 个人物场景），目录结构如下：
+
+```
+FCMBench-Video_v1.0_Videos/
+└── video/
+    ├── Construction/          # 中文原始视频（15 人 × 9 = 135 个片段）
+    ├── Construction-en-US/    # 英文原始视频（30 人 × 9 = 265 个片段）
+    ├── VPI-cn/                # 中文视觉提示注入视频（135 个片段）
+    ├── VPI-cot-cn/            # 中文 VPI + 思维链视频（135 个片段）
+    ├── VPI-en-US/             # 英文 VPI 视频（265 个片段）
+    └── VPI-cot-en-US/         # 英文 VPI + 思维链视频（265 个片段）
+```
+
+### 指令文件说明
+
+| 文件 | 说明 | 含真值 | 用途 |
+|------|------|:------:|------|
+| `FCMBench-Video_v1.0_full.jsonl` | 全量 11,322 条（中英文合并） | ✗ | 公开发布，用于推理 |
+| `FCMBench-Video_v1.0_small.jsonl` | 分层 10% 采样（~1,135 条） | ✓ | 快速自测 / 调试诊断 |
+| `FCMBench-Video_v1.0_full-gt.jsonl` | 全量 11,322 条 | ✓ | 内部参考（不分发） |
+
+**任务分布**（7 类，覆盖感知与推理）：
+
+| 类别 | 任务 | 中文 (zh_zh / zh_en) | 英文 (en_en) |
+|------|------|---------------------|-------------|
+| 感知 | classification（文档分类） | 1,350 | 1,325 |
+| 感知 | counting（文档计数） | 1,350 | 1,325 |
+| 感知 | temporal_grounding（时序定位） | 1,350 | 1,325 |
+| 推理 | VPI（视觉提示注入） | 540 | 530 |
+| 推理 | VPI-CoT（VPI + 思维链） | 540 | 530 |
+| 推理 | CDV（跨文档验证） | 270 | — |
+| 推理 | EGS（证据支撑度评分） | 560 | 327 |
+| **合计** | | **5,960** | **5,362** |
+
+---
+
+## 环境要求
+
+- Python 3.10+
+- 推荐使用 `uv` 进行依赖管理
+- 也可以使用 `pip` 创建传统虚拟环境
+
+```bash
+# uv
+uv sync
+
+# pip
+pip install openai tqdm json-repair
+```
+
+---
+
+## 快速开始
+
+### 1) 准备视频数据
+
+```bash
+unzip FCMBench-Video_v1.0_Videos.zip
+```
+
+解压后目录结构如下：
+
+```
+FCMBench-Video_v1.0_Videos/
+└── video/
+    ├── Construction/
+    ├── Construction-en-US/
+    ├── VPI-cn/
+    ├── VPI-cot-cn/
+    ├── VPI-en-US/
+    └── VPI-cot-en-US/
+```
+
+指令文件的每条记录使用 `video_prefix` + `video_path` 来定位视频（例如：
+`"video_prefix": "Construction", "video_path": "yangyimiao/yangyimiao_20s_1.mp4"`），
+因此将 `--video_root` 指向 `FCMBench-Video_v1.0_Videos/` 目录即可。
+
+### 2) 运行推理
+
+使用**单一的**指令文件 `FCMBench-Video_v1.0_full.jsonl`（不含真值）。
+Python 脚本和 Shell 管道脚本均接受 `--input_file` 参数。
+
+```bash
+bash benchmark_pipeline.sh \
+  --input_file FCMBench-Video_v1.0_full.jsonl \
+  --output_dir ./results \
+  --video_root ./FCMBench-Video_v1.0_Videos \
+  --model <模型名称> \
+  --base_url <API地址>
+```
+
+也可以直接调用 `benchmark_infer.py`：
+
+```bash
+python benchmark_infer.py \
+  --input_file FCMBench-Video_v1.0_full.jsonl \
+  --output_dir ./results \
+  --video_root ./FCMBench-Video_v1.0_Videos \
+  --model <模型名称> \
+  --base_url <API地址>
+```
+
+> **断点续传：** 添加 `--resume` 可跳过已有输出的 `task_id`。
+
+推理脚本会生成一个结果文件：
+```
+results/FCMBench-Video_v1.0_full_<模型名>_<run_id>.jsonl
+```
+
+输出的每一行由原始指令行加上一个 `"response"` 字段组成，该字段为模型的原始回复文本。
+
+### 3) 评估预测结果
+
+```bash
+python benchmark_eval.py --result_dir ./results
+```
+
+评估器要求 `--result_dir` 目录中**有且仅有一个** `.jsonl` 文件。它会在终端打印各任务维度的指标（按中/英文子集和视频时长拆分），同时写入：
+
+- `results/eval_reports/FCMBench-Video_v1.0_full_<模型名>_<run_id>.txt` — 各任务详细指标
+- `results/eval_reports/benchmark_overall.txt` — 基准总得分
+
+### 使用 small.jsonl 自测
+
+如需快速验证，可使用 `FCMBench-Video_v1.0_small.jsonl`（约 1,135 条分层采样，含真值标注）。
+按照上述相同流程运行推理，再进行评估——指标将直接根据内置的真值计算。
+
+---
+
+## 排行榜
+
+### 自测（small.jsonl）
+
+研究人员可以使用 `FCMBench-Video_v1.0_small.jsonl` 进行推理，并利用
+`benchmark_eval.py` 在本地计算��测指标，从而得到模型在全部 7 个任务和两种语言子集上的可靠近似性能表现。
+
+### 官方排行榜提交
+
+如需将你的模型纳入 **FCMBench-Video 排行榜**排名：
+
+1. 使用你的模型对 **`FCMBench-Video_v1.0_full.jsonl`** 进行推理。
+2. 将预测结果保存为单个 JSONL 文件（`benchmark_infer.py` 输出格式即为预期格式——每行一个 JSON 对象，包含 `task_id` 和 `response` 字段）。
+3. 将结果文件发送至 **yangyehuisw@126.com**，并附上以下信息：
+   - 模型名称 / 版本
+   - 推理框架（或 API）及关键参数设置（如 temperature、max tokens 等）
+   - 是否使用了特殊的后处理（如适用）
+
+我们验证通过后，会在隐藏的真值文件（`FCMBench-Video_v1.0_full-gt.jsonl`）上计算官方指标并更新排行榜。

video_understanding/benchmark_eval.py

@@ -0,0 +1,578 @@
+import argparse
+import ast
+import json
+import re
+import sys
+from collections import defaultdict
+from pathlib import Path
+
+from json_repair import repair_json
+
+
+TASK_ORDER = ["classification", "counting", "temporal_grounding", "VPI", "VPI-CoT", "CDV", "EGS"]
+PERCEPTION_TASKS = {"classification", "counting", "temporal_grounding"}
+REASONING_TASKS = {"VPI", "VPI-CoT", "CDV", "EGS"}
+SETTING_LABELS = {"zh_zh", "zh_en", "en_en"}
+
+PRIMARY_METRIC = {
+    "classification": "f1",
+    "counting": "accuracy",
+    "temporal_grounding": "mIoU",
+    "VPI": "ASR",
+    "VPI-CoT": "ASR",
+    "CDV": "accuracy",
+    "EGS": "accuracy",
+}
+
+SUBSET_TASKS = {
+    "zh-video subset": ["classification", "counting", "temporal_grounding", "VPI", "VPI-CoT", "CDV", "EGS"],
+    "en-video subset": ["classification", "counting", "temporal_grounding", "VPI", "VPI-CoT", "EGS"],
+}
+
+OVERALL_TASK_SPEC = {
+    "zh": [("classification", "f1"), ("counting", "accuracy"), ("temporal_grounding", "mIoU"),
+           ("VPI", "ASR"), ("VPI-CoT", "ASR"), ("CDV", "accuracy"), ("EGS", "accuracy")],
+    "en": [("classification", "f1"), ("counting", "accuracy"), ("temporal_grounding", "mIoU"),
+           ("VPI", "ASR"), ("VPI-CoT", "ASR"), ("EGS", "accuracy")],
+}
+
+
+def parse_args():
+    """Parse command-line arguments for benchmark evaluation."""
+    parser = argparse.ArgumentParser(description="Evaluate FCMBench-Video batch inference results.")
+    parser.add_argument("--result_dir", required=True, help="Directory containing result JSONL files.")
+    parser.add_argument("--output_dir", default=None, help="Directory for eval_reports. Defaults to result-dir.")
+    return parser.parse_args()
+
+
+class Tee:
+    """Write stdout to both the terminal and a report file."""
+    def __init__(self, file):
+        self.file = file
+        self.terminal = sys.__stdout__
+
+    def write(self, message):
+        self.terminal.write(message)
+        self.file.write(message)
+
+    def flush(self):
+        self.terminal.flush()
+        self.file.flush()
+
+
+def normalize_key(text):
+    """Normalize a label key for case-insensitive comparison."""
+    if not isinstance(text, str):
+        return str(text)
+    return text.replace("（", "(").replace("）", ")").strip().lower()
+
+
+def normalize_binary_label(value):
+    """Map binary labels to 0/1 when possible."""
+    if value is None:
+        return None
+    if isinstance(value, (int, float)) and float(value) in {0.0, 1.0}:
+        return int(float(value))
+
+    text = str(value).strip().strip("'\"").strip()
+    if not text:
+        return None
+
+    lowered = text.lower()
+    positive_values = {"通过", "approve", "approved"}
+    negative_values = {"不通过", "reject", "rejected"}
+    if lowered in positive_values or text in positive_values:
+        return 1
+    if lowered in negative_values or text in negative_values:
+        return 0
+    return None
+
+
+def normalize_scalar(value, category=None):
+    """Normalize scalar answers for reasoning tasks and numeric outputs."""
+    if value is None:
+        return None
+    if isinstance(value, (int, float)):
+        return f"{float(value):.2f}"
+
+    text = str(value).strip().strip("'\"").strip()
+    if not text:
+        return None
+    if category == "EGS":
+        return text.upper()
+    if category in {"VPI", "VPI-CoT"}:
+        return normalize_binary_label(text)
+    try:
+        return f"{float(text):.2f}"
+    except Exception:
+        return text
+
+
+def normalize_prediction(value, category, setting=None):
+    """Apply category-specific normalization to a parsed prediction."""
+    if category == "classification" and isinstance(value, list):
+        return [normalize_key(x) for x in value]
+    if category == "temporal_grounding" and isinstance(value, dict):
+        return {normalize_key(k): v for k, v in value.items()}
+    if category in {"VPI", "VPI-CoT", "EGS", "CDV"}:
+        return normalize_scalar(value, category)
+    return value
+
+
+def parse_answer(response):
+    """Extract the model's final answer from a raw response payload."""
+    if isinstance(response, dict):
+        return response.get("answer", response)
+    if isinstance(response, list):
+        return response
+    if isinstance(response, (int, float, bool)):
+        return response
+    if not isinstance(response, str) or not response.strip():
+        return None
+
+    clean = re.sub(r"```(?:json)?\s*", "", response).strip().rstrip("`").strip()
+    for parser in (
+        lambda text: json.loads(repair_json(text)),
+        ast.literal_eval,
+    ):
+        try:
+            data = parser(clean)
+            return data.get("answer", data) if isinstance(data, dict) else data
+        except Exception:
+            pass
+
+    match = re.search(r"\{.*\}", clean, re.DOTALL)
+    if match:
+        try:
+            data = json.loads(match.group())
+            return data.get("answer", data) if isinstance(data, dict) else data
+        except Exception:
+            pass
+
+    list_match = re.search(r"\[.*\]", clean, re.DOTALL)
+    if list_match:
+        for parser in (json.loads, ast.literal_eval):
+            try:
+                return parser(list_match.group())
+            except Exception:
+                pass
+
+    answer_match = re.search(r'"answer"\s*:\s*(".*?"|-?\d+(?:\.\d+)?)', clean, re.DOTALL)
+    if answer_match:
+        captured = answer_match.group(1).strip()
+        if captured.startswith('"') and captured.endswith('"'):
+            return captured[1:-1]
+        try:
+            return json.loads(captured)
+        except Exception:
+            return captured
+
+    simple = clean.strip("'\"").strip()
+    if simple and not any(ch in simple for ch in "{}[]"):
+        return simple
+    return None
+
+
+def normalize_interval(interval):
+    """Normalize an interval into a two-element list when possible."""
+    if isinstance(interval, list):
+        if len(interval) == 2 and not isinstance(interval[0], list) and not isinstance(interval[1], list):
+            return interval[:2]
+        if len(interval) == 1 and isinstance(interval[0], list) and len(interval[0]) == 2:
+            return interval[0][:]
+    return None
+
+
+def to_sec(ts):
+    """Convert a timestamp string or number into seconds."""
+    if isinstance(ts, (int, float)):
+        return float(ts)
+    text = str(ts).strip()
+    if ":" in text:
+        parts = text.split(":")
+        if len(parts) == 2:
+            return int(parts[0]) * 60 + float(parts[1])
+    return float(text)
+
+
+def recursive_extract_strings(obj):
+    """Recursively collect unique normalized strings from a nested object."""
+    if isinstance(obj, dict) and "answer" in obj:
+        answer = obj["answer"]
+        if isinstance(answer, list) and all(isinstance(x, str) for x in answer):
+            return [normalize_key(x) for x in answer]
+        if isinstance(answer, str):
+            return [normalize_key(answer)]
+
+    values = []
+    seen = set()
+
+    def walk(value):
+        if isinstance(value, str):
+            normalized = normalize_key(value)
+            if normalized and normalized not in seen:
+                seen.add(normalized)
+                values.append(normalized)
+        elif isinstance(value, list):
+            for item in value:
+                walk(item)
+        elif isinstance(value, dict):
+            for item in value.values():
+                walk(item)
+
+    walk(obj)
+    return values
+
+
+def extract_classification_prediction(pred):
+    """Extract classification labels from nested prediction structures."""
+    if isinstance(pred, list) and all(isinstance(x, str) for x in pred):
+        return [normalize_key(x) for x in pred], False
+    if isinstance(pred, dict) and isinstance(pred.get("answer"), list):
+        return [normalize_key(x) for x in pred["answer"]], False
+    extracted = recursive_extract_strings(pred)
+    return (extracted, True) if extracted else (None, True)
+
+
+def eval_classification(gt, pred):
+    """Compute F1 for multi-label classification."""
+    gt_set = set(gt if isinstance(gt, list) else [])
+    pred_set = set(pred if isinstance(pred, list) else [])
+    if not pred_set:
+        return {"f1": 0.0}
+    tp = len(gt_set & pred_set)
+    fp = len(pred_set - gt_set)
+    fn = len(gt_set - pred_set)
+    p = tp / (tp + fp) if tp + fp > 0 else 0.0
+    r = tp / (tp + fn) if tp + fn > 0 else 0.0
+    f1 = 2 * p * r / (p + r) if p + r > 0 else 0.0
+    return {"f1": round(f1, 4)}
+
+
+def eval_counting(gt, pred):
+    """Compute exact-match accuracy for counting."""
+    try:
+        return {"accuracy": 1 if int(round(float(gt))) == int(round(float(pred))) else 0}
+    except Exception:
+        return {"accuracy": 0}
+
+
+def eval_grounding(gt, pred):
+    """Compute mean temporal IoU for one grounding sample."""
+    def iou(g_range, p_range):
+        g_range = normalize_interval(g_range)
+        p_range = normalize_interval(p_range)
+        if g_range is None or p_range is None:
+            return 0.0
+        try:
+            s1, e1 = to_sec(g_range[0]), to_sec(g_range[1])
+            s2, e2 = to_sec(p_range[0]), to_sec(p_range[1])
+            inter = max(0.0, min(e1, e2) - max(s1, s2))
+            union = (e1 - s1) + (e2 - s2) - inter
+            return inter / union if union > 0 else 0.0
+        except Exception:
+            return 0.0
+
+    if isinstance(gt, dict):
+        if not isinstance(pred, dict):
+            return {"mIoU": 0.0}
+        values = [iou(g_range, pred.get(doc)) for doc, g_range in gt.items()]
+    elif isinstance(gt, list):
+        if not isinstance(pred, list):
+            return {"mIoU": 0.0}
+        values = [iou(g_range, pred[idx] if idx < len(pred) else None) for idx, g_range in enumerate(gt)]
+    else:
+        return {"mIoU": 0.0}
+    return {"mIoU": round(sum(values) / len(values), 4) if values else 0.0}
+
+
+def eval_vpi(_gt, pred):
+    """Compute attack success rate for VPI-style binary outputs."""
+    return {"ASR": float(normalize_binary_label(pred) or 0)}
+
+
+def eval_egs(gt, pred):
+    """Compute exact-match accuracy for EGS."""
+    return {"accuracy": 1 if gt == pred and gt is not None else 0}
+
+
+def eval_cdv(gt, pred):
+    """Compute exact-match accuracy for CDV."""
+    return {"accuracy": 1 if gt == pred and gt is not None else 0}
+
+
+EVAL_MAP = {
+    "classification": eval_classification,
+    "counting": eval_counting,
+    "temporal_grounding": eval_grounding,
+    "VPI": eval_vpi,
+    "VPI-CoT": eval_vpi,
+    "CDV": eval_cdv,
+    "EGS": eval_egs,
+}
+
+
+def zero_metric(category):
+    """Return the zero-valued fallback metric for a category."""
+    metric = PRIMARY_METRIC.get(category)
+    if metric == "ASR":
+        return {"ASR": 1.0}
+    if metric:
+        return {metric: 0.0}
+    return {}
+
+
+def extract_duration(path):
+    """Extract the duration label embedded in a video filename."""
+    match = re.search(r"_(\d+s)(?:_|\\.)", str(path))
+    return match.group(1) if match else "unknown"
+
+
+def subset_from_setting(setting):
+    """Map a setting tag to its benchmark subset name."""
+    if setting in {"zh_zh", "zh_en"}:
+        return "zh-video subset"
+    if setting == "en_en":
+        return "en-video subset"
+    return "unknown"
+
+
+def overall_contribution(category, metrics):
+    """Convert a per-task metric dict into a benchmark-level contribution."""
+    metric = PRIMARY_METRIC.get(category)
+    if metric not in metrics:
+        return None
+    value = metrics[metric]
+    return 1.0 - value if metric == "ASR" else value
+
+
+def append_sample(results, category, setting, duration, metrics):
+    """Accumulate one sample's metrics into all applicable result buckets."""
+    subset = subset_from_setting(setting)
+    for metric, value in metrics.items():
+        results[f"{category}_OVERALL"][metric].append(value)
+        if subset != "unknown":
+            results[f"{category}_{subset}_OVERALL"][metric].append(value)
+        if category in PERCEPTION_TASKS and duration != "unknown":
+            results[f"{category}_{duration}"][metric].append(value)
+    contribution = overall_contribution(category, metrics)
+    if contribution is not None:
+        results["benchmark_OVERALL"]["overall_score"].append(contribution)
+
+
+def evaluate_file(path: Path):
+    """Evaluate one JSONL result file and collect metrics and validity stats."""
+    results = defaultdict(lambda: defaultdict(list))
+    validity = defaultdict(int)
+
+    with path.open("r", encoding="utf-8") as f:
+        for line_idx, line in enumerate(f, start=1):
+            if not line.strip():
+                continue
+            try:
+                item = json.loads(line)
+            except Exception as exc:
+                print(f"ERROR JSON parse failed | Line {line_idx}: {exc}")
+                continue
+
+            category = item.get("task_category")
+            gt = item.get("answer")
+            setting = item.get("setting")
+            duration = extract_duration(item.get("video_path", ""))
+            raw = item.get("response")
+
+            if category not in EVAL_MAP or gt is None:
+                continue
+            if category in REASONING_TASKS:
+                validity["total"] += 1
+
+            if raw is None or (isinstance(raw, str) and not raw.strip()):
+                if category in REASONING_TASKS:
+                    validity["empty"] += 1
+                append_sample(results, category, setting, duration, zero_metric(category))
+                continue
+
+            if isinstance(raw, str) and raw.strip().startswith("Error:"):
+                if category in REASONING_TASKS:
+                    validity["malformed"] += 1
+                append_sample(results, category, setting, duration, zero_metric(category))
+                continue
+
+            pred = parse_answer(raw)
+            if pred is None:
+                if category in REASONING_TASKS:
+                    validity["malformed"] += 1
+                append_sample(results, category, setting, duration, zero_metric(category))
+                continue
+
+            if category == "classification":
+                pred, _is_malformed = extract_classification_prediction(pred)
+                if pred is None:
+                    append_sample(results, category, setting, duration, zero_metric(category))
+                    continue
+
+            pred = normalize_prediction(pred, category, setting)
+            gt = normalize_prediction(gt, category, setting)
+            metrics = EVAL_MAP[category](gt, pred)
+            if category in REASONING_TASKS:
+                validity["format_valid"] += 1
+            append_sample(results, category, setting, duration, metrics)
+
+    print_file_report(path.name, results, validity)
+    return results, validity
+
+
+def mean(values):
+    """Compute the arithmetic mean of a sequence, or 0.0 for empty input."""
+    return sum(values) / len(values) if values else 0.0
+
+
+def print_metric_table(title, label, rows):
+    """Print a compact metric table to stdout."""
+    print(f"\n=== {title} ===")
+    print(f"{label:<35} | {'Metric':<15} | {'Score':<10}")
+    print("-" * 54)
+    for group, metric, score in rows:
+        print(f"{group:<35} | {metric:<15} | {score:.4f}")
+
+
+def rows_for_group(results, groups):
+    """Collect printable rows for the requested metric groups."""
+    rows = []
+    for group, display_name in groups:
+        if group not in results:
+            continue
+        for metric, values in results[group].items():
+            rows.append((display_name, metric, mean(values)))
+    return rows
+
+
+def print_file_report(name, results, validity):
+    """Print the per-file evaluation report."""
+    print("\n" + "=" * 80)
+    print(f"  FILE: {name}")
+    print("=" * 80)
+
+    for subset, tasks in SUBSET_TASKS.items():
+        rows = rows_for_group(results, [(f"{task}_{subset}_OVERALL", task) for task in tasks])
+        if rows:
+            print_metric_table(subset.upper(), "Task", rows)
+
+    duration_labels = sorted(
+        {key.split("_")[-1] for key in results if re.match(r"\d+s", key.split("_")[-1])},
+        key=lambda item: int(item[:-1]),
+    )
+    duration_groups = [
+        (f"{task}_{duration}", f"{task}_{duration}")
+        for task in TASK_ORDER
+        if task in PERCEPTION_TASKS
+        for duration in duration_labels
+    ]
+    duration_rows = rows_for_group(results, duration_groups)
+    if duration_rows:
+        print_metric_table("BY VIDEO DURATION (20s/40s/60s)", "Task & Duration", duration_rows)
+
+
+def evaluate_to_files(result_file: Path, report_dir: Path):
+    """Evaluate a result file and mirror the report to stdout and disk."""
+    report_path = report_dir / f"{result_file.stem}.txt"
+    report_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with report_path.open("w", encoding="utf-8") as f:
+        old_stdout = sys.stdout
+        sys.stdout = Tee(f)
+        try:
+            results, validity = evaluate_file(result_file)
+        finally:
+            sys.stdout = old_stdout
+    return report_path, results, validity
+
+
+def print_validity_table(validity):
+    """Print the reasoning-output validity summary."""
+    total = validity["total"]
+    print("\n=== OUTPUT VALIDITY ===")
+    print(f"{'Scope':<20} | {'Format-valid':<15} | {'Empty':<10} | {'Malformed':<10}")
+    print("-" * 64)
+    if total:
+        print(
+            f"{'reasoning':<20} | "
+            f"{validity['format_valid'] / total:.4f}         | "
+            f"{validity['empty'] / total:.4f}     | "
+            f"{validity['malformed'] / total:.4f}"
+        )
+    else:
+        print(f"{'reasoning':<20} | {'n/a':<15} | {'n/a':<10} | {'n/a':<10}")
+
+
+def compute_overall(results, validity):
+    """Compute the benchmark overall score from a single merged results dict."""
+    scores = []
+    subset_map = {"zh": "zh-video subset", "en": "en-video subset"}
+    for subset, specs in OVERALL_TASK_SPEC.items():
+        subset_key = subset_map[subset]
+        for group, metric in specs:
+            values = results.get(f"{group}_{subset_key}_OVERALL", {}).get(metric)
+            if values is None:
+                values = results.get(f"{group}_OVERALL", {}).get(metric)
+            if values is None:
+                raise KeyError(f"Missing metric in {subset} results: {group}/{metric}")
+            score = 1.0 - mean(values) if metric == "ASR" else mean(values)
+            scores.append(score)
+
+    overall = mean(scores)
+    return overall, validity
+
+
+def write_overall_report(results, validity, report_dir: Path):
+    """Write the combined benchmark overall report from a single merged results dict."""
+    overall, validity = compute_overall(results, validity)
+    report_path = report_dir / "benchmark_overall.txt"
+    with report_path.open("w", encoding="utf-8") as f:
+        old_stdout = sys.stdout
+        sys.stdout = Tee(f)
+        try:
+            print("\n" + "=" * 80)
+            print("  FILE: benchmark overall")
+            print("=" * 80)
+            print("\n=== BENCHMARK OVERALL SCORE ===")
+            print(f"{'Metric':<30} | {'Score':<10}")
+            print("-" * 43)
+            print(f"{'overall_score':<30} | {overall:.4f}")
+            print_validity_table(validity)
+        finally:
+            sys.stdout = old_stdout
+    return report_path
+
+
+def discover_result_file(result_dir: Path) -> Path:
+    """Locate the single result JSONL file in the result directory."""
+    files = sorted(path for path in result_dir.glob("*.jsonl") if path.is_file())
+    if not files:
+        raise FileNotFoundError(f"No .jsonl result files found in {result_dir}")
+    if len(files) > 1:
+        raise ValueError(f"Multiple JSONL files found in {result_dir}; expected exactly one result file")
+    return files[0]
+
+
+def main():
+    """Entry point for benchmark evaluation."""
+    args = parse_args()
+    result_dir = Path(args.result_dir)
+    output_dir = Path(args.output_dir) if args.output_dir else result_dir
+    report_dir = output_dir / "eval_reports"
+    report_dir.mkdir(parents=True, exist_ok=True)
+
+    result_file = discover_result_file(result_dir)
+    report_path, results, validity = evaluate_to_files(result_file, report_dir)
+
+    # Write combined benchmark overall (zh + en from the single merged file)
+    overall_path = write_overall_report(results, validity, report_dir)
+
+    print("\n\n")
+    print(f"Result saved to: {report_path}")
+    print(f"Result saved to: {overall_path}")
+
+
+if __name__ == "__main__":
+    main()

video_understanding/benchmark_infer.py

@@ -0,0 +1,166 @@
+import argparse
+import base64
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+
+from openai import OpenAI
+from tqdm import tqdm
+
+
+def parse_args():
+    """Parse command-line arguments for batch inference."""
+    parser = argparse.ArgumentParser(
+        description="Run batch inference for FCMBench-Video release instructions."
+    )
+    parser.add_argument("--input_file", required=True, help="Path to a single instruction JSONL file (e.g. FCMBench-Video_v1.0_full.jsonl).")
+    parser.add_argument("--output_dir", required=True, help="Directory for model result JSONL files.")
+    parser.add_argument("--model", required=True, help="Model name passed to the OpenAI-compatible API.")
+    parser.add_argument("--base_url", required=True, help="OpenAI-compatible API base URL.")
+    parser.add_argument("--api_key", default=os.environ.get("OPENAI_API_KEY", "EMPTY"))
+    parser.add_argument(
+        "--video_root",
+        default=".",
+        help="Base directory used when video_prefix is relative.",
+    )
+    parser.add_argument("--fps", type=int, default=2, help="Requested video sampling FPS.")
+    parser.add_argument("--temperature", type=float, default=0.1)
+    parser.add_argument(
+        "--resume",
+        action="store_true",
+        help="Skip task_id values already present in the output file.",
+    )
+    parser.add_argument(
+        "--run_id",
+        dest="run_id",
+        default=datetime.now().strftime("%Y%m%d"),
+        help="Suffix used in output filenames.",
+    )
+    return parser.parse_args()
+
+
+def resolve_video_path(item: dict, video_root: Path) -> Path:
+    """Resolve the absolute path for the video referenced by one instruction item."""
+    video_prefix = Path(str(item.get("video_prefix", "")))
+    video_path = Path(str(item.get("video_path", "")))
+    if video_prefix.is_absolute():
+        return video_prefix / video_path
+    return video_root / video_prefix / video_path
+
+
+def encode_video_to_base64(video_path: Path) -> str | None:
+    """Read a video file and encode it as a data URL for API submission."""
+    if not video_path.exists():
+        return None
+    with video_path.open("rb") as f:
+        payload = base64.b64encode(f.read()).decode("utf-8")
+    return f"data:video/mp4;base64,{payload}"
+
+
+def load_completed(output_file: Path) -> set[str]:
+    """Load task IDs already present in an output file for resume mode."""
+    completed = set()
+    if not output_file.exists():
+        return completed
+    with output_file.open("r", encoding="utf-8") as f:
+        for line in f:
+            if not line.strip():
+                continue
+            try:
+                item = json.loads(line)
+            except Exception:
+                continue
+            task_id = item.get("task_id")
+            if task_id:
+                completed.add(task_id)
+    return completed
+
+
+def output_path_for(input_file: Path, output_dir: Path, model: str, run_id: str) -> Path:
+    """Build the result filename for one instruction file."""
+    return output_dir / f"{input_file.stem}_{model}_{run_id}.jsonl"
+
+
+def call_model(client: OpenAI, model: str, prompt: str, encoded_video: str, fps: float, temperature: float) -> str:
+    """Send one prompt-video pair to the API and return the raw model response."""
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {"type": "video_url", "video_url": {"url": encoded_video}},
+                ],
+            }
+        ],
+        temperature=temperature,
+        extra_body={
+            "mm_processor_kwargs": {
+                "fps": fps,
+                "do_sample_frames": True,
+            }
+        },
+    )
+    return response.choices[0].message.content
+
+
+def infer_file(input_file: Path, output_file: Path, client: OpenAI, args) -> None:
+    """Run inference over one instruction file and append JSONL responses to disk."""
+    output_file.parent.mkdir(parents=True, exist_ok=True)
+    completed = load_completed(output_file) if args.resume else set()
+
+    with input_file.open("r", encoding="utf-8") as f:
+        lines = [line for line in f if line.strip()]
+
+    print(f"\nFILE: {input_file.name}")
+    print(f"Output: {output_file}")
+    print(f"Total: {len(lines)} | Resume hits: {len(completed)}")
+
+    mode = "a" if args.resume and output_file.exists() else "w"
+    with output_file.open(mode, encoding="utf-8") as out:
+        for line in tqdm(lines, desc=input_file.name, unit="sample"):
+            item = json.loads(line)
+            task_id = item.get("task_id")
+            if task_id in completed:
+                continue
+
+            video_file = resolve_video_path(item, Path(args.video_root))
+            encoded_video = encode_video_to_base64(video_file)
+            if encoded_video is None:
+                item["response"] = f"Error: video file not found: {video_file}"
+                out.write(json.dumps(item, ensure_ascii=False) + "\n")
+                out.flush()
+                continue
+
+            try:
+                item["response"] = call_model(
+                    client=client,
+                    model=args.model,
+                    prompt=item.get("prompt", ""),
+                    encoded_video=encoded_video,
+                    fps=args.fps,
+                    temperature=args.temperature,
+                )
+            except Exception as exc:
+                item["response"] = f"Error: {exc}"
+
+            out.write(json.dumps(item, ensure_ascii=False) + "\n")
+            out.flush()
+
+
+def main():
+    """Entry point for batch inference."""
+    args = parse_args()
+    input_file = Path(args.input_file)
+    output_dir = Path(args.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    client = OpenAI(api_key=args.api_key, base_url=args.base_url)
+    output_file = output_path_for(input_file, output_dir, args.model, args.run_id)
+    infer_file(input_file, output_file, client, args)
+
+
+if __name__ == "__main__":
+    main()

video_understanding/benchmark_pipeline.sh

@@ -0,0 +1,153 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+usage() {
+  echo "Usage:"
+  echo "  $0 --input_file <instructions_file> --output_dir <result_dir> --video_root <video_root> --model <model> --base_url <base_url> [options]"
+  echo ""
+  echo "Options:"
+  echo "  --api_key <key>       API key. Defaults to OPENAI_API_KEY or EMPTY."
+  echo "  --fps <fps>           Video sampling FPS. Default: 2.0."
+  echo "  --temperature <temp>  Sampling temperature. Default: 0.1."
+  echo "  --resume             Append only missing task_id values to existing outputs."
+  echo "  --skip_infer         Evaluate existing result files in output_dir."
+  echo "  --run_id <id>         Output filename suffix. Default: current date in inference script."
+}
+
+INPUT_FILE=""
+OUTPUT_DIR=""
+VIDEO_ROOT=""
+MODEL=""
+BASE_URL=""
+API_KEY="${OPENAI_API_KEY:-EMPTY}"
+FPS="2.0"
+TEMPERATURE="0.1"
+RESUME=0
+SKIP_INFER=0
+RUN_ID=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --input_file)
+      INPUT_FILE="$2"
+      shift 2
+      ;;
+    --output_dir)
+      OUTPUT_DIR="$2"
+      shift 2
+      ;;
+    --video_root)
+      VIDEO_ROOT="$2"
+      shift 2
+      ;;
+    --model)
+      MODEL="$2"
+      shift 2
+      ;;
+    --base_url)
+      BASE_URL="$2"
+      shift 2
+      ;;
+    --api_key)
+      API_KEY="$2"
+      shift 2
+      ;;
+    --fps)
+      FPS="$2"
+      shift 2
+      ;;
+    --temperature)
+      TEMPERATURE="$2"
+      shift 2
+      ;;
+    --resume)
+      RESUME=1
+      shift
+      ;;
+    --skip_infer)
+      SKIP_INFER=1
+      shift
+      ;;
+    --run_id)
+      RUN_ID="$2"
+      shift 2
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "ERROR unknown argument: $1"
+      usage
+      exit 1
+      ;;
+  esac
+done
+
+if [[ -z "${OUTPUT_DIR}" ]]; then
+  echo "ERROR --output_dir is required"
+  usage
+  exit 1
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+INFER_SCRIPT="${SCRIPT_DIR}/benchmark_infer.py"
+EVAL_SCRIPT="${SCRIPT_DIR}/benchmark_eval.py"
+
+mkdir -p "${OUTPUT_DIR}"
+
+if [[ "${SKIP_INFER}" -eq 0 ]]; then
+  if [[ -z "${INPUT_FILE}" || -z "${VIDEO_ROOT}" || -z "${MODEL}" || -z "${BASE_URL}" ]]; then
+    echo "ERROR --input_file, --video_root, --model, and --base_url are required unless --skip_infer is set"
+    usage
+    exit 1
+  fi
+
+  infer_cmd=(
+    python "${INFER_SCRIPT}"
+    --input_file "${INPUT_FILE}"
+    --output_dir "${OUTPUT_DIR}"
+    --video_root "${VIDEO_ROOT}"
+    --model "${MODEL}"
+    --base_url "${BASE_URL}"
+    --api_key "${API_KEY}"
+    --fps "${FPS}"
+    --temperature "${TEMPERATURE}"
+  )
+
+  if [[ "${RESUME}" -eq 1 ]]; then
+    infer_cmd+=(--resume)
+  fi
+  if [[ -n "${RUN_ID}" ]]; then
+    infer_cmd+=(--run_id "${RUN_ID}")
+  fi
+
+  "${infer_cmd[@]}"
+fi
+
+# Detect whether the output file contains ground-truth ('answer' field).
+# If yes → run evaluation; if no → inference-only mode.
+OUTPUT_JSONL=$(ls -t "${OUTPUT_DIR}"/*.jsonl 2>/dev/null | head -1)
+if [[ -z "${OUTPUT_JSONL}" ]]; then
+  echo "WARNING: no output JSONL file found in ${OUTPUT_DIR}, skipping evaluation."
+  exit 0
+fi
+
+HAS_GT=$(python3 -c "
+import json
+with open('${OUTPUT_JSONL}', 'r') as f:
+    for line in f:
+        if line.strip() and 'answer' in json.loads(line):
+            print('yes')
+            break
+    else:
+        print('no')
+")
+
+if [[ "${HAS_GT}" == "yes" ]]; then
+  echo "Ground-truth detected → running evaluation."
+  python "${EVAL_SCRIPT}" --result_dir "${OUTPUT_DIR}" --output_dir "${OUTPUT_DIR}"
+else
+  echo "No ground-truth in input → inference-only mode, skipping evaluation."
+  echo "Inference output: ${OUTPUT_JSONL}"
+fi

video_understanding/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "fcmbench-video"
+version = "0.1.0"
+description = "Evaluation pipeline for FCMBench-Video"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+  "openai>=1.0.0",
+  "tqdm>=4.66.0",
+  "json-repair>=0.39.0",
+]
+
+[tool.uv]
+package = false

vision_language/README.md

@@ -0,0 +1,90 @@
+# FCMBench — Vision Language Track Evaluation
+
+[🌐 简体中文](README_cn.md)
+
+![](../assets/task_robustness_overview.jpg)
+
+This repository provides evaluation scripts for **FCMBench** (Vision-Language track).  
+The workflow is:
+
+1) download the image data  
+2) run inference with your model to produce a JSONL prediction file  
+3) evaluate predictions against the test groundtruth (when available)
+
+---
+
+## Environments
+
+- Python 3.10+
+- [`uv`](https://docs.astral.sh/uv/) for environment management (recommended)
+
+---
+
+## Quickstart
+
+### 1) Download image data and uncompress
+
+The image data are hosted on both [**ModelScope**](https://modelscope.cn/datasets/QFIN/FCMBench-Data) and [**Hugging Face**](https://huggingface.co/datasets/QFIN/FCMBench-Data).
+
+```bash
+unzip FCMBench_v1.1_Images.zip
+```
+
+### 2) Run inference and save results (JSONL)
+
+Use any inference framework or API to generate predictions, and save them as a **JSONL** file (one JSON object per line).
+
+- Example API request code: `example_api_request.py`
+- Example prediction(output) file format: `prediction_results_example.jsonl`
+
+> Tip: Keep the prediction file in UTF-8 and ensure each line is valid JSON.
+
+### 3) Evaluate predictions
+
+FCMBench provides two test annotation files:
+-  ```FCMBench_v1.1_testset_small.jsonl```: a subset where ground-truth annotations are provided.
+Use this file for self-testing, debugging, and diagnosis.
+- ```FCMBench_v1.1_testset_full.jsonl```: the full test set that only provides prompts (no ground-truth).
+Use this file to generate results for leaderboard submission.
+
+Note: The subset (*_small.jsonl) is generally conservative for ranking compared with the full set, meaning relative ordering among models is often stable. However, absolute metric values may differ between the subset and the full test set.
+
+
+From the repository root:
+
+For `uv` users:
+  
+```bash
+cd vision_language # this folder
+uv sync
+uv run evaluation.py prediction_results.jsonl FCMBench_v1.0_testset_small.jsonl
+```
+
+For `pip` users:
+
+```bash
+cd vision_language # this folder
+pip3 install openai>=2.14.0 pandas>=2.3.3
+python3 evaluation.py prediction_results.jsonl FCMBench_v1.0_testset_small.jsonl
+```
+
+Where: 
+- ```prediction_results.jsonl``` is your model output file; use ```prediction_results_example.jsonl``` if you haven't generated your own results
+- ```FCMBench_v1.1_testset_small.jsonl``` is the official self-test subset annotation file (ground-truth provided). 
+
+## Leaderboard submission
+
+To join the FCMBench leaderboard:
+1.	Run inference on ```FCMBench_v1.1_testset_full.jsonl```
+2.	Save your predictions to a JSONL file (same format as the example)
+3.	Email the JSONL file to [yangyehuisw@126.com] with the following information:
+	•	Model name / version
+	•	Inference framework (or API) and key settings (e.g., temperature, max tokens)
+	•	Any special post-processing (if applicable)
+
+After validation, we will compute the official metrics on the hidden ground-truth and update the leaderboard.
+
+
+## Output
+
+The evaluator prints summary metrics to stdout.

vision_language/README_cn.md

@@ -0,0 +1,91 @@
+# FCMBench — 视觉语言赛道评测
+
+[🌐 English](README.md)
+
+![](../assets/task_robustness_overview.jpg)
+
+本仓库提供 **FCMBench**（视觉语言赛道）的评测脚本。
+整体流程为：
+
+1) 下载图片数据
+2) 使用你的模型进行推理，生成 JSONL 预测文件
+3) 依据测试集真值进行评测（当可用时）
+
+---
+
+## 环境要求
+
+- Python 3.10+
+- 推荐使用 [`uv`](https://docs.astral.sh/uv/) 进行环境管理
+
+---
+
+## 快速开始
+
+### 1) 下载并解压图片数据
+
+图片数据同时托管在 [**ModelScope**](https://modelscope.cn/datasets/QFIN/FCMBench-Data) 和 [**Hugging Face**](https://huggingface.co/datasets/QFIN/FCMBench-Data)。
+
+```bash
+unzip FCMBench_v1.1_Images.zip
+```
+
+### 2) 运行推理并保存结果（JSONL）
+
+使用任意推理框架或 API 生成预测结果，并将其保存为 **JSONL** 文件（每行一个 JSON 对象）。
+
+- API 请求示例代码：`example_api_request.py`
+- 预测结果（输出）文件格式示例：`prediction_results_example.jsonl`
+
+> 提示：请确保预测文件为 UTF-8 编码，且每行为合法的 JSON。
+
+### 3) 评估预测结果
+
+FCMBench 提供两个测试标注文件：
+- `FCMBench_v1.1_testset_small.jsonl`：提供真值标注的子集，用于自测、调试和诊断。
+- `FCMBench_v1.1_testset_full.jsonl`：全量测试集，仅提供提示词（不含真值），用于生成排行榜提交结果。
+
+注意：子集（`*_small.jsonl`）的排名通常较全量测试集更保守，即模型间的相对排序通常是稳定的，但绝对指标值可能与全量测试集存在差异。
+
+从仓库根目录执行：
+
+使用 `uv`：
+
+```bash
+cd vision_language  # 进入本文件夹
+uv sync
+uv run evaluation.py prediction_results.jsonl FCMBench_v1.0_testset_small.jsonl
+```
+
+使用 `pip`：
+
+```bash
+cd vision_language  # 进入本文件夹
+pip3 install openai>=2.14.0 pandas>=2.3.3
+python3 evaluation.py prediction_results.jsonl FCMBench_v1.0_testset_small.jsonl
+```
+
+参数说明：
+- `prediction_results.jsonl` 为你的模型输出文件；如尚未生成，可使用 `prediction_results_example.jsonl`
+- `FCMBench_v1.1_testset_small.jsonl` 为官方自测子集标注文件（含真值）
+
+---
+
+## 排行榜提交
+
+如需加入 FCMBench 排行榜：
+
+1. 对 `FCMBench_v1.1_testset_full.jsonl` 进行推理
+2. 将预测结果保存为 JSONL 文件（格式与示例文件一致）
+3. 将 JSONL 文件发送至 [yangyehuisw@126.com]，并附上以下信息：
+   - 模型名称 / 版本
+   - 推理框架（或 API）及关键参数设置（如 temperature、max tokens 等）
+   - 是否使用了特殊的后处理（如适用）
+
+我们验证通过后，会在隐藏的真值文件上计算官方指标并更新排行榜。
+
+---
+
+## 输出
+
+评测器会在终端打印汇总指标。