Add files using upload-large-folder tool

cambw_lmms_eval/README.md

@@ -0,0 +1,52 @@
+# Cambrian-W x lmms-eval
+
+- **part1**: long videos (part1_long_videos dual_format_appearance).
+- **part2_3**: short videos = part2 (place & motion) + part3 (objects dual format fixed_choices).
+
+## Layout
+
+- `data/`: part1_long.jsonl, part2_3_short.jsonl (from prepare_data.py)
+- `scripts/prepare_data.py`: flatten benchmark to docs with resolved video_path
+- `scripts/run_with_cambw_backend.py`: run with cambw original backends (same as eval_cambw)
+- `tasks/cambw/`: YAML tasks + utils (doc_to_text, doc_to_visual, process_results)
+- `lmms_eval_adapter/`: notes for optional lmms-eval model adapter (cambw backends)
+
+## Usage
+
+1. Generate data:
+   python scripts/prepare_data.py --benchmark-dir <cambw>/benchmark_single --data-root <cambw>/data --out-dir data
+2. Run: lmms_eval --model <model> --tasks cambw_part1_long --include_path <this_dir>/tasks
+   (Pass dataset_path / data_root via task_args if needed.)
+   Or use cambw backends (same as eval_cambw, recommended):
+   python scripts/run_with_cambw_backend.py --model-name qwen_vl_2_5_7b --backend qwen_vl --data data/part1_long.jsonl --output-dir out --cambw-root /path/to/xty/cambw
+
+Path resolution uses same SOURCE_FOLDER_TO_DATA_SUBDIR as cambw eval_cambw.py (see utils.py). Model adaptation: use run_with_cambw_backend.py to run with cambw original backends (same as eval_cambw), so model side is not worse than lmms-eval.
+
+## 直接测试（用 lmms_eval 跑 Cambrian-W）
+
+1. **准备数据**（未做过则执行一次）  
+   ```bash
+   cd /path/to/gtj/cambw_lmms_eval
+   export CAMBW_ROOT="/path/to/xty/cambw"
+   python scripts/prepare_data.py --benchmark-dir "${CAMBW_ROOT}/benchmark_single" --data-root "${CAMBW_ROOT}/data" --out-dir data
+   ```
+
+2. **激活已安装 lmms_eval 的环境**（conda 或 venv，需含 lmms_eval、accelerate、datasets 等）。
+
+3. **在仓库根目录执行**（数据路径相对本目录，故必须在 cambw_lmms_eval 下跑）  
+   ```bash
+   cd /path/to/gtj/cambw_lmms_eval
+   # 若 lmms_eval 不在当前 env 的 path，指定其包所在目录
+   export LMMS_EVAL_ROOT=/path/to/xxx/lmms_eval   # 例如 .../thinking-in-space/lmms_eval
+   bash run_lmms_eval.sh <模型名> <limit>
+   # 例: bash run_lmms_eval.sh qwen2_vl_2b 4
+   ```  
+   或直接：  
+   `lmms_eval --model <模型名> --tasks cambw_part1_long --include_path "$(pwd)/tasks" --limit 4`
+
+4. **Task 配置**：已改为 `dataset_path: json` + `dataset_kwargs.data_files.test: data/part1_long.jsonl`、`test_split: test`、`doc_to_target: "answer"`，以及 `!function utils.doc_to_text`（与 lmms_eval 的 !function 同目录 utils.py 约定一致）。
+
+- **lmms-eval 本体**：不 fork、不修改，使用原版 lmms-eval（同一代码库、同一 CLI）。
+- **完全一致**有两种方式：
+  1. **用 lmms-eval 整条流程**：原版 lmms-eval + 本仓库 tasks（--include_path）+ 将 `lmms_eval_adapter/cambw_backend.py` 复制到 lmms-eval 的 models 并注册为 `cambw_*`；跑时设 `CAMBW_ROOT=/path/to/xty/cambw`。这样调度、task、输出格式都是 lmms-eval，仅模型实现为 cambw backends，推理与 eval_cambw.py 完全一致。
+  2. **用独立 runner**：`scripts/run_with_cambw_backend.py` 不经过 lmms-eval 的 model 层，但推理 100% 与 cambw 一致；输出格式与 eval_cambw 相同。

cambw_lmms_eval/lmms_eval_adapter/README.md

@@ -0,0 +1,48 @@
+# lmms-eval model adapter for Cambrian-W (cambw backends)
+
+**方式 1：整条链路都在 lmms-eval 里（和原版 lmms-eval 最一致）**
+
+使用**原版 lmms-eval**（不 fork、不改其代码），只做两件事：加入本仓库的 tasks（`--include_path`）+ 将本目录的 **cambw_backend.py** 复制到 lmms-eval 并注册。这样 `lmms_eval --model cambw_* --tasks cambw_*` 的调度、task、输出都是 lmms-eval，推理 100% 走 cambw backends。
+
+## 步骤 1：设置环境变量
+
+```bash
+export CAMBW_ROOT=/path/to/xty/cambw   # 含 eval_cambw.py 的目录
+```
+
+## 步骤 2：把适配器加入 lmms-eval
+
+1. 找到你的 lmms-eval 源码目录，例如：`/path/to/lmms-eval`（或 `lmms_eval` 包所在目录）。
+2. 将本仓库的 **cambw_backend.py** 复制到 lmms-eval 的 models 目录下（若无 `simple` 子目录可放在 `models/` 下并相应改导入）：
+   ```bash
+   cp /path/to/gtj/cambw_lmms_eval/lmms_eval_adapter/cambw_backend.py /path/to/lmms-eval/lmms_eval/models/simple/
+   ```
+3. 在 `lmms_eval/models/simple/__init__.py` 末尾添加一行，使适配器被注册：
+   ```python
+   from .cambw_backend import CAMBWBackend  # noqa: F401
+   ```
+4. 若 lmms-eval 在实例化 model 时未传入 `model_name`，可再设：
+   ```bash
+   export CAMBW_MODEL_NAME=cambw_qwen_vl_2_5_7b
+   ```
+
+## 步骤 3：跑 Cambrian-W 任务
+
+```bash
+lmms_eval --model cambw_qwen_vl_2_5_7b \
+  --tasks cambw_part1_long \
+  --include_path /path/to/gtj/cambw_lmms_eval/tasks
+```
+
+数据：先在本仓库内运行 `scripts/prepare_data.py` 生成 `data/part1_long.jsonl`（及 part2_3），并在 task YAML 或 `--task_args` 中指定 `dataset_path` 指向该 JSONL（可为绝对路径）。
+
+---
+
+Adapter 逻辑：`generate_until(requests)` 中从每个 `Instance.args` 解出 `context`（prompt）和 `visual_list`；`visual_list` 与 `doc_to_visual` 约定一致：`[video_path]` 或 `[video_path, frame_indices]`。然后调用 `build_backend(...).generate(prompt, video_path=..., frame_indices=...)`，与 eval_cambw.py 完全一致。
+
+若你使用的 lmms-eval 版本中 `Instance.args` 的元组顺序或结构不同，只需在 `cambw_backend.py` 的 `generate_until` 里调整解包顺序即可（见注释）。
+
+---
+
+**不改 lmms-eval 时的替代**：用独立 runner，推理同样 100% cambw：
+  python scripts/run_with_cambw_backend.py --model-name qwen_vl_2_5_7b --backend qwen_vl --data data/part1_long.jsonl --output-dir out --cambw-root /path/to/xty/cambw

cambw_lmms_eval/lmms_eval_adapter/cambw_backend.py

@@ -0,0 +1,111 @@
+"""
+lmms-eval 完整 model 适配器：整条链路在 lmms-eval 内，推理 100% 走 xty/cambw backends。
+复制到 lmms-eval 源码中并注册后，--model cambw_qwen_vl_2_5_7b 与原版 lmms-eval 完全一致。
+
+安装步骤（在 lmms-eval 源码目录内）：
+1. 设置环境变量: export CAMBW_ROOT=/path/to/xty/cambw
+2. 复制本文件到 lmms_eval/models/simple/cambw_backend.py
+3. 在 lmms_eval/models/simple/__init__.py 末尾添加:
+   from .cambw_backend import CAMBWBackend  # noqa: F401
+4. 运行: lmms_eval --model cambw_qwen_vl_2_5_7b --tasks cambw_part1_long --include_path /path/to/gtj/cambw_lmms_eval/tasks
+"""
+from __future__ import annotations
+
+import os
+import sys
+from typing import List, Tuple
+
+# 确保能 import lmms_eval（本文件应放在 lmms_eval 包内）
+try:
+    from lmms_eval.api.model import lmms
+    from lmms_eval.api.registry import register_model
+    from lmms_eval.api.instance import Instance
+except ImportError:
+    lmms = object  # 仅本地测试时
+    def register_model(*names):
+        def dec(cls):
+            return cls
+        return dec
+    Instance = None
+
+# cambw 根目录：环境变量优先，其次 arg_string 中的 cambw_root=
+CAMBW_ROOT = os.environ.get("CAMBW_ROOT", "")
+
+# 模型名 -> (backend_name, model_name)，与 xty/cambw workflow 一致
+CAMBW_MODEL_MAP = {
+    "cambw_llava_video_7b": ("llava_video", "llava_video_7b"),
+    "cambw_llava_onevision_7b": ("llava_onevision", "llava_onevision_7b"),
+    "cambw_llava_onevision_0_5b": ("llava_onevision", "llava_onevision_0_5b"),
+    "cambw_qwen_vl_2_5_7b": ("qwen_vl", "qwen_vl_2_5_7b"),
+    "cambw_qwen_vl_2_5_3b": ("qwen_vl", "qwen_vl_2_5_3b"),
+    "cambw_qwen_vl_2_5_0_5b": ("qwen_vl", "qwen_vl_2_5_0_5b"),
+    "cambw_internvl2_5_8b": ("internvl2_5", "internvl2_5_8b"),
+    "cambw_internvl3_5_8b": ("internvl3_5", "internvl3_5_8b"),
+    "cambw_cambrian_s_7b": ("cambrian_s", "cambrian_s_7b"),
+}
+
+
+@register_model(
+    "cambw_llava_video_7b",
+    "cambw_llava_onevision_7b",
+    "cambw_llava_onevision_0_5b",
+    "cambw_qwen_vl_2_5_7b",
+    "cambw_qwen_vl_2_5_3b",
+    "cambw_qwen_vl_2_5_0_5b",
+    "cambw_internvl2_5_8b",
+    "cambw_internvl3_5_8b",
+    "cambw_cambrian_s_7b",
+)
+class CAMBWBackend(lmms):
+    """lmms-eval model 实现：转调 xty/cambw 的 build_backend().generate()，与 eval_cambw 完全一致。"""
+
+    def __init__(self, model_name: str = None, cambw_root: str = None, **kwargs):
+        super().__init__()
+        self._model_name = model_name or os.environ.get("CAMBW_MODEL_NAME", "cambw_qwen_vl_2_5_7b")
+        self._cambw_root = (cambw_root or os.environ.get("CAMBW_ROOT", "")).strip()
+        if self._cambw_root and self._cambw_root not in sys.path:
+            sys.path.insert(0, os.path.abspath(self._cambw_root))
+        self._backend = None  # 延迟加载
+
+    def _get_backend(self):
+        if self._backend is not None:
+            return self._backend
+        pair = CAMBW_MODEL_MAP.get(self._model_name)
+        if not pair:
+            raise ValueError(f"Unknown cambw model: {self._model_name}. Supported: {list(CAMBW_MODEL_MAP.keys())}")
+        backend_name, backend_model_name = pair
+        from eval_cambw import build_backend
+        self._backend = build_backend(backend_name, backend_model_name)
+        return self._backend
+
+    def generate_until(self, requests: List[Instance]) -> List[str]:
+        """与 cambw 原版 backend.generate 一致：prompt + video_path + frame_indices。"""
+        results = []
+        for req in requests:
+            args = req.args if hasattr(req, "args") else ((),)
+            if not isinstance(args, (list, tuple)):
+                args = (args,)
+            # 常见约定: (context, until, generation_kwargs, visual_list) 或 (context, until, visual_list)
+            context = args[0] if len(args) > 0 else ""
+            visual_list = None
+            if len(args) > 3:
+                visual_list = args[3]
+            elif len(args) > 2 and isinstance(args[2], (list, tuple)):
+                visual_list = args[2]
+            video_path = None
+            frame_indices = None
+            if visual_list and len(visual_list) > 0:
+                v0 = visual_list[0]
+                if isinstance(v0, (list, tuple)):
+                    video_path = v0[0] if len(v0) > 0 else None
+                    frame_indices = v0[1] if len(v0) > 1 else None
+                else:
+                    video_path = v0
+            backend = self._get_backend()
+            out = backend.generate(context, video_path=video_path, frame_indices=frame_indices)
+            results.append(out.text if hasattr(out, "text") else str(out))
+        return results
+
+    def loglikelihood(self, requests: List[Instance]) -> List[Tuple[float, bool]]:
+        """Cambrian-W 任务用 generate_until 即可；若任务走 loglikelihood 可返回占位。"""
+        return [(0.0, False)] * len(requests)

cambw_lmms_eval/run.sh

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+lmms_eval --model your_video_model --tasks cambw_part1_long --include_path "${ROOT}/tasks" --limit 4

cambw_lmms_eval/run_lmms_eval.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+# 在 cambw_lmms_eval 目录下用 lmms_eval 直接测 Cambrian-W。
+# 用法: bash run_lmms_eval.sh [模型名] [limit]
+# 例:   bash run_lmms_eval.sh qwen2_vl_2b 4
+# 需先: 1) 安装 lmms_eval  2) 在本目录运行过 scripts/prepare_data.py 生成 data/*.jsonl
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "$0")" && pwd)"
+cd "$ROOT"
+
+MODEL="${1:-qwen2_vl_2b}"
+LIMIT="${2:-4}"
+
+# 若本机 lmms_eval 在别处，可设 LMMS_EVAL_ROOT 指向**包含 lmms_eval 包的目录**（即 import lmms_eval 时所在的那一层）
+if [ -n "${LMMS_EVAL_ROOT:-}" ]; then
+  LMMS_PARENT="$(cd "${LMMS_EVAL_ROOT}/.." && pwd)"
+  export PYTHONPATH="${LMMS_PARENT}${PYTHONPATH:+:$PYTHONPATH}"
+fi
+
+python -m lmms_eval --model "$MODEL" --tasks cambw_part1_long --include_path "${ROOT}/tasks" --limit "$LIMIT"

cambw_lmms_eval/scripts/prepare_data.py

@@ -0,0 +1,143 @@
+#!/usr/bin/env python3
+"""
+从 Cambrian-W benchmark_single 的 part1 / part2 / part3 JSON 生成 lmms-eval 用的 doc 列表（JSONL）。
+- part1_long: part1_long_videos_-_dual_format_appearance.json
+- part2_3_short: part2_short_videos_-_place_&_motion.json + part3_short_videos_-_objects_with_dual_format_fixed_choices.json
+每个 doc = 一个 checkpoint 级别的评估项（含 video_path, task_type, question, answer, frame_indices 等）。
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+SOURCE_FOLDER_TO_DATA_SUBDIR = {
+    "new_long_video/corrected_json_2": "new_long_video_persp",
+    "top20merge/corrected_json": "top20merge_0207_persp",
+    "long_video/corrected_json_2": "long_video_persp",
+    "top20merge_full/corrected_json_2": "top20merge_0207_persp",
+}
+
+
+def resolve_video_path(video: Dict[str, Any], data_root: str) -> Optional[str]:
+    video_path = video.get("video_path") or video.get("video")
+    if video_path:
+        video_path = str(video_path).strip()
+        if os.path.isabs(video_path):
+            for old_prefix in [
+                "/lustre/fs12/portfolios/nvr/projects/nvr_av_end2endav/users/ymingli/projects/xty/cambw/data",
+                "/lustre/fsw/portfolios/nvr/users/ymingli/projects/xty/cambw/data",
+                "/data",
+                "/path/to/data",
+            ]:
+                if video_path.startswith(old_prefix):
+                    video_path = os.path.join(data_root, video_path[len(old_prefix):].lstrip("/"))
+                    break
+        else:
+            video_path = os.path.join(data_root, video_path)
+        return video_path
+    video_name = video.get("video_name")
+    source_folder = video.get("source_folder")
+    if not video_name or not source_folder:
+        return None
+    subdir = SOURCE_FOLDER_TO_DATA_SUBDIR.get(source_folder)
+    if not subdir:
+        return None
+    base = video_name if video_name.endswith(".mp4") else f"{video_name}.mp4"
+    return os.path.join(data_root, subdir, base)
+
+
+def task_has_valid_checkpoints(task: Dict[str, Any]) -> bool:
+    return any(cp.get("answer") is not None for cp in task.get("checkpoints", []))
+
+
+def flatten_part1(bench_path: Path, data_root: str) -> List[Dict[str, Any]]:
+    with bench_path.open("r") as f:
+        data = json.load(f)
+    docs = []
+    for v in data.get("videos") or []:
+        video_path = resolve_video_path(v, data_root)
+        if not video_path:
+            continue
+        video_name = v.get("video_name", "")
+        tasks = v.get("tasks") or []
+        for ti, t in enumerate(tasks):
+            if not task_has_valid_checkpoints(t):
+                continue
+            ttype = t.get("task_type", "")
+            if t.get("variant"):
+                ttype = f"{ttype}_{t['variant']}"
+            for cpi, cp in enumerate(t.get("checkpoints", [])):
+                if cp.get("answer") is None:
+                    continue
+                doc = {
+                    "doc_id": f"{video_name}|{ti}|{ttype}|{cpi}",
+                    "video_name": video_name,
+                    "video_path": video_path,
+                    "task_type": ttype,
+                    "question": t.get("question", ""),
+                    "answer": cp["answer"],
+                }
+                if ttype == "frame_recall" and cp.get("frames"):
+                    doc["frame_indices"] = [int(f["frame_idx"]) for f in cp["frames"]]
+                else:
+                    doc["frame_indices"] = None
+                if cp.get("options") is not None:
+                    doc["options"] = cp["options"]
+                else:
+                    doc["options"] = None
+                if t.get("subset_concepts") is not None:
+                    doc["subset_concepts"] = t["subset_concepts"]
+                else:
+                    doc["subset_concepts"] = None
+                docs.append(doc)
+    return docs
+
+
+def flatten_part2_or_part3(bench_path: Path, data_root: str) -> List[Dict[str, Any]]:
+    return flatten_part1(bench_path, data_root)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--benchmark-dir", type=str, required=True)
+    parser.add_argument("--data-root", type=str, required=True)
+    parser.add_argument("--out-dir", type=str, default="data")
+    args = parser.parse_args()
+    bench_dir = Path(args.benchmark_dir)
+    out_dir = Path(args.out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    part1_file = bench_dir / "part1_long_videos_-_dual_format_appearance.json"
+    if part1_file.exists():
+        docs1 = flatten_part1(part1_file, args.data_root)
+        out1 = out_dir / "part1_long.jsonl"
+        with out1.open("w") as f:
+            for d in docs1:
+                f.write(json.dumps(d, ensure_ascii=False) + "\n")
+        print(f"part1_long: {len(docs1)} docs -> {out1}")
+    else:
+        print(f"Skip part1: not found {part1_file}")
+
+    part2_file = bench_dir / "part2_short_videos_-_place_&_motion.json"
+    part3_file = bench_dir / "part3_short_videos_-_objects_with_dual_format_fixed_choices.json"
+    docs2_3 = []
+    if part2_file.exists():
+        docs2_3.extend(flatten_part2_or_part3(part2_file, args.data_root))
+        print(f"part2: {len(docs2_3)} docs")
+    if part3_file.exists():
+        n_before = len(docs2_3)
+        docs2_3.extend(flatten_part2_or_part3(part3_file, args.data_root))
+        print(f"part3: +{len(docs2_3) - n_before} docs")
+    if docs2_3:
+        out2_3 = out_dir / "part2_3_short.jsonl"
+        with out2_3.open("w") as f:
+            for d in docs2_3:
+                f.write(json.dumps(d, ensure_ascii=False) + "\n")
+        print(f"part2_3_short: {len(docs2_3)} docs -> {out2_3}")
+
+
+if __name__ == "__main__":
+    main()

cambw_lmms_eval/scripts/run_with_cambw_backend.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Run Cambrian-W with cambw original backends (same as eval_cambw.py)."""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from pathlib import Path
+
+_REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(_REPO_ROOT))
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--model-name", type=str, required=True)
+    parser.add_argument("--backend", type=str, required=True)
+    parser.add_argument("--data", type=str, required=True)
+    parser.add_argument("--output-dir", type=str, required=True)
+    parser.add_argument("--cambw-root", type=str, required=True)
+    parser.add_argument("--max-samples", type=int, default=-1)
+    parser.add_argument("--rank", type=int, default=0)
+    parser.add_argument("--world-size", type=int, default=1)
+    args = parser.parse_args()
+
+    cambw_root = os.path.abspath(args.cambw_root)
+    if cambw_root not in sys.path:
+        sys.path.insert(0, cambw_root)
+    from eval_cambw import build_backend
+
+    from tasks.cambw import utils as cambw_utils
+
+    backend = build_backend(args.backend, args.model_name)
+
+    with open(args.data) as f:
+        docs = [json.loads(line) for line in f if line.strip()]
+
+    if args.world_size > 1:
+        docs = [d for i, d in enumerate(docs) if i % args.world_size == args.rank]
+    if args.max_samples > 0:
+        docs = docs[: args.max_samples]
+
+    all_results = {}
+    total = len(docs)
+    prefix = f"[rank {args.rank}] " if args.world_size > 1 else ""
+
+    for idx, doc in enumerate(docs):
+        prompt = cambw_utils.doc_to_text(doc)
+        visual = cambw_utils.doc_to_visual(doc)
+        video_path = visual[0] if visual else None
+        frame_indices = visual[1] if len(visual) > 1 else None
+        out = backend.generate(prompt, video_path=video_path, frame_indices=frame_indices)
+        res = cambw_utils.process_results(doc, [out.text])
+        key = res.get("task_type", "unknown")
+        all_results.setdefault(key, []).append(res)
+        if (idx + 1) % 50 == 0 or idx == total - 1:
+            print(f"{prefix}[{idx+1}/{total}]", flush=True)
+
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out_file = out_dir / (f"results_raw_rank{args.rank}.json" if args.world_size > 1 else "results_raw.json")
+    with out_file.open("w") as f:
+        json.dump(all_results, f, ensure_ascii=False)
+
+    if args.world_size == 1:
+        flat = [r for items in all_results.values() for r in items]
+        summaries = cambw_utils.aggregate_results(flat)
+        with (out_dir / "results_summary.json").open("w") as f:
+            json.dump(summaries, f, indent=2, ensure_ascii=False)
+        print("Summary:", summaries)
+    print(f"{prefix}Wrote {out_file}")
+
+
+if __name__ == "__main__":
+    main()

cambw_lmms_eval/tasks/cambw/__init__.py

@@ -0,0 +1 @@
+# Cambrian-W tasks for lmms-eval (part1 long, part2_3 short)

cambw_lmms_eval/tasks/cambw/cambw_part1_long.yaml

@@ -0,0 +1,14 @@
+# Cambrian-W Part1 Long Videos
+task: cambw_part1_long
+description: "Cambrian-W part1 long videos (40 videos)"
+dataset_path: json
+dataset_name: null
+dataset_kwargs:
+  data_files:
+    test: data/part1_long.jsonl
+test_split: test
+doc_to_text: !function utils.doc_to_text
+doc_to_visual: !function utils.doc_to_visual
+doc_to_target: "answer"
+process_results: !function utils.process_results
+output_type: generate_until

cambw_lmms_eval/tasks/cambw/cambw_part2_3_short.yaml

@@ -0,0 +1,14 @@
+# Cambrian-W Part2+3 Short Videos
+task: cambw_part2_3_short
+description: "Cambrian-W part2+3 short videos"
+dataset_path: json
+dataset_name: null
+dataset_kwargs:
+  data_files:
+    test: data/part2_3_short.jsonl
+test_split: test
+doc_to_text: !function utils.doc_to_text
+doc_to_visual: !function utils.doc_to_visual
+doc_to_target: "answer"
+process_results: !function utils.process_results
+output_type: generate_until

cambw_lmms_eval/tasks/cambw/utils.py

@@ -0,0 +1,102 @@
+# Cambrian-W task utils for lmms-eval: doc_to_text, doc_to_visual, process_results.
+# Logic aligned with xty/cambw/eval_cambw.py (clean_question, parse_sequence, extract_letter, MRA).
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List
+
+
+def clean_question_for_prompt(question: str) -> str:
+    q = re.sub(
+        r"\.\s*At each checkpoint,\s*report the cumulative count up to that point as a single integer\.",
+        ". Report the total count up to this point as a single integer.",
+        question,
+    )
+    q = re.sub(
+        r"\.\s*At each checkpoint,\s*arrange all seen objects",
+        ". Arrange all seen objects",
+        q,
+    )
+    q = q.replace("From the video you have watched so far, here are", "Here are")
+    return q
+
+
+def parse_sequence(text: str) -> str:
+    text = text.upper().replace("\u2192", "").replace("->", "").replace(" ", "").replace(",", "")
+    match = re.search(r"[ABCD]{2,4}", text)
+    return match.group(0) if match else ""
+
+
+def extract_letter(text: str) -> str:
+    text = text.upper()
+    for letter in ["A", "B", "C", "D"]:
+        if letter in text:
+            return letter
+    return "A"
+
+
+def doc_to_text(doc: Dict[str, Any]) -> str:
+    question = clean_question_for_prompt(doc.get("question", ""))
+    task_type = (doc.get("task_type") or "").lower()
+    if "direct" in task_type and "appearance" in task_type:
+        concepts = doc.get("subset_concepts") or []
+        concept_list = "\n".join(f"{chr(ord('A') + i)}) {c}" for i, c in enumerate(concepts))
+        n = len(concepts)
+        return f"{question}\n\nObjects:\n{concept_list}\n\nOutput the order as a sequence of {n} letters.\nAnswer with only the {n} letters in order, nothing else."
+    if doc.get("options"):
+        options_str = "\n".join(doc["options"])
+        return f"{question}\n\nOptions:\n{options_str}\n\nAnswer with only the letter (A, B, C, or D)."
+    if "count" in task_type:
+        return f"{question}\n\nAnswer with only a single integer number."
+    return question
+
+
+def doc_to_visual(doc: Dict[str, Any]) -> List[Any]:
+    out = [doc.get("video_path")]
+    if doc.get("frame_indices"):
+        out.append(doc["frame_indices"])
+    return out
+
+
+def process_results(doc: Dict[str, Any], results: List[str]) -> Dict[str, Any]:
+    text = (results[0] or "").strip() if results else ""
+    task_type = (doc.get("task_type") or "").lower()
+    gt = doc.get("answer")
+    out = {"doc_id": doc.get("doc_id"), "gt": gt, "pred_raw": text, "task_type": doc.get("task_type") or "unknown"}
+    if "direct" in task_type and "appearance" in task_type:
+        pred = parse_sequence(text)
+        out["pred"] = pred
+        out["correct"] = pred == gt
+        return out
+    if doc.get("options") is not None or "choice" in task_type or "recall" in task_type or "motion" in task_type:
+        pred = extract_letter(text)
+        out["pred"] = pred
+        out["correct"] = pred == gt
+        return out
+    if "count" in task_type:
+        nums = re.findall(r"\d+", text)
+        pred_val = int(nums[0]) if nums else 0
+        gt_val = gt if isinstance(gt, int) else int(gt)
+        mra = max(0.0, 1.0 - abs(pred_val - gt_val) / max(gt_val, 1))
+        out["pred"] = pred_val
+        out["mra"] = mra
+        return out
+    return out
+
+
+def aggregate_results(results: List[Dict[str, Any]]) -> Dict[str, Any]:
+    by_type = {}
+    for r in results:
+        t = r.get("task_type") or "unknown"
+        by_type.setdefault(t, []).append(r)
+    metrics = {}
+    for t, items in by_type.items():
+        if not items:
+            continue
+        if "correct" in items[0]:
+            acc = sum(int(x.get("correct", False)) for x in items) / len(items) * 100.0
+            metrics[f"{t}_accuracy"] = acc
+        if "mra" in items[0]:
+            mra = sum(x.get("mra", 0) for x in items) / len(items) * 100.0
+            metrics[f"{t}_mra"] = mra
+    return metrics

output_json.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2776a51771f3375725f27388037ef7bbe51d3d45bd96a33324be29a8dd1ec2a4
+size 10424760

output_json/streetview_final_filtered.json

@@ -0,0 +1,42 @@
+{
+  "categories": [
+    {
+      "name": "Urban Streetscapes & City Walks",
+      "subtypes": [
+        {
+          "name": "downtown tokyo walk",
+          "videos": []
+        },
+        {
+          "name": "rainy night seoul",
+          "videos": []
+        },
+        {
+          "name": "kyoto historic district",
+          "videos": []
+        },
+        {
+          "name": "new york city walk",
+          "videos": []
+        },
+        {
+          "name": "parisian streets",
+          "videos": []
+        }
+      ]
+    }
+  ],
+  "_yt_meta_enrich_summary": {
+    "ok": 1520,
+    "failed": 2048,
+    "cache_dir": "/home/user/hyn/Hstar/yt_meta_cache"
+  },
+  "_meta": {
+    "frames_root": "./streetview_hub_video_frames",
+    "frames_per_video": 6,
+    "min_score_keep": 9.0,
+    "vision_model": "Qwen/Qwen3-VL-235B-A22B-Instruct",
+    "img_base_url": "http://127.0.0.1:18081",
+    "geo_level": "continent+country"
+  }
+}