"""ESTP-Bench async build entry —— 严格仿照 ``ovobench_async_processing.py``。 设计原则(与 CLAUDE.md 一致:尽量复用、不改动现有代码): * 逐帧 caption / HyperVideoGraph / async pipeline(v1/v2/v3)全部复用 ``ovobench_async_processing._run_one_video_async``,不重写一行流水逻辑。 * 仅替换三处 ESTP 特有部分: 1. 数据加载: 读 ESTP 两层 dict json, 抽取 164 个有 QA 的 video_uuid。 2. 视频路径: full_scale_2fps_max384/{video_uuid}.mp4。 3. caption prompt: 用 FRAME_CAPTION_WINDOW_ESTP_PROMPT(通过 _run_one_video_async 已有的 caption_prompt_template 参数注入, 它在 batch 模式下是最高优先级模板, 无需改 ovobench 代码)。 * 输出目录: all_results/estp_hyper/{video_uuid}_{caption_model_name}/ 运行示例(必须先 export LD_LIBRARY_PATH, 且从 VideoRAG-algorithm 目录用 -m 跑): export LD_LIBRARY_PATH=/root/miniconda3/envs/egoserve/lib:$LD_LIBRARY_PATH python -m hypervideo.estp_async_processing \ --caption_model_name qwen_vllm \ --vllm_base_url http://10.0.0.27:8001/v1 \ --vllm_model_name Qwen3-VL-8B-Instruct \ --only_uuids "200a8f32-c44a-463d-ba39-0190a0bddf7a,..." \ --cuda 0 """ from __future__ import annotations import argparse import json import logging import os import sys import time from typing import List, Optional sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from videorag._utils import always_get_an_event_loop # noqa: E402 from hypervideo.hyper_video_graph import HyperVideoGraph # noqa: E402 from hypervideo.modules.async_pipeline import AsyncPipelineStats, LLMTimer # noqa: E402 from hypervideo.config import HyperVideoConfig # noqa: E402 # 复用 ovobench 的所有流水实现(caption / builder / async pipeline / save)。 from hypervideo.ovobench_async_processing import _run_one_video_async # noqa: E402 from hypervideo.ovobench_hyper_processing import ( # noqa: E402 _reset_hyper_vg_working_dir, default_llm_config, clear_gpu_memory, ) # ESTP 专用 caption prompt(本次新增, 不改任何现有 prompt)。 from hypervideo.prompts.frame_caption_prompt import ( # noqa: E402 FRAME_CAPTION_WINDOW_ESTP_PROMPT, FRAME_CAPTION_WINDOW_ESTP_QAWARE_PROMPT, FRAME_CAPTION_WINDOW_ESTP_QAWARE_V2_PROMPT, ) logging.basicConfig(level=logging.INFO) logger = logging.getLogger(__name__) # ===================================================================== # 数据加载 —— ESTP 两层 dict -> 扁平 video 列表 # ===================================================================== def load_estp_videos(data_path: str) -> List[dict]: """[旧, 保留不删] 逐视频整段建图单位(164 个视频, 每个一张超图)。 建图单位是 video_uuid; QA / segment 信息仅用于日志统计。 现已被 ``load_estp_clips`` 取代(建图单位改为唯一 clip 区间), 仅为向后兼容保留。""" with open(data_path, "r", encoding="utf-8") as f: all_data = json.load(f) videos: List[dict] = [] for video_uuid, qa_dict in all_data.items(): if not qa_dict: # 没有任何 QA 的视频跳过 continue n_seg = 0 for _qa_uuid, segs in qa_dict.items(): if isinstance(segs, list): n_seg += len(segs) videos.append({ "id": video_uuid, "n_qa": len(qa_dict), "n_segments": n_seg, }) return videos def _estp_item_clip_range(item: dict): """从单个 QA item 取 (clip_start_sec, clip_end_sec)。 ESTP json 里有两种 item schema: A) {'clip_start_time', 'clip_end_time', 'Task Type', 'question', 'qa_id', ...} B) {'start_time', 'end_time', 'duration', 'video_uid', 'Task Type', ...} 两者都表示一个 clip 时间区间, 统一抽出。""" if "clip_start_time" in item: return float(item["clip_start_time"]), float(item["clip_end_time"]) return float(item["start_time"]), float(item["end_time"]) def load_estp_clips(data_path: str) -> List[dict]: """读取 ESTP json({video_uuid: {segment_uuid: [qa_item, ...]}}), 按 **唯一 clip 区间** 返回建图单位列表。 建图单位 = 唯一 (video_uuid, clip_start_time, clip_end_time) 三元组, 而不是整视频, 也不是单条 QA。同一 clip 下的多个 QA 共用一张图。 返回每项: { 'id' : 用作 working_dir 区分的唯一键 (含 video + clip 区间), 'video_uuid' : 视频 uuid (用于定位 mp4), 'clip_start_time' : float 秒, 'clip_end_time' : float 秒, 'segment_uuid' : 代表性 segment_uuid (若一个 clip 跨多个则取首个), 'segment_uuids' : 该 clip 命中的全部 segment_uuid 列表, 'n_qa' : 该 clip 覆盖的 QA 数, } 注意: 同一 clip 区间可能被多个 segment_uuid 引用; 此处按区间去重, 一个区间只 建一张图。""" with open(data_path, "r", encoding="utf-8") as f: all_data = json.load(f) # key=(video_uuid, clip_start, clip_end) -> 聚合信息 agg = {} for video_uuid, seg_dict in all_data.items(): if not seg_dict: continue for segment_uuid, items in seg_dict.items(): if not isinstance(items, list): continue for it in items: try: cs, ce = _estp_item_clip_range(it) except (KeyError, TypeError, ValueError): logger.warning(f" 跳过缺时间区间的 item: video={video_uuid} seg={segment_uuid}") continue key = (video_uuid, cs, ce) rec = agg.get(key) if rec is None: rec = { "video_uuid": video_uuid, "clip_start_time": cs, "clip_end_time": ce, "segment_uuids": [], "n_qa": 0, # q-aware 建图用: 收集该 clip 覆盖的全部 (qa_id, question)。 "questions": [], } agg[key] = rec if segment_uuid not in rec["segment_uuids"]: rec["segment_uuids"].append(segment_uuid) rec["n_qa"] += 1 # 收集问题文本(开放式, 无 options)。两种 schema: # A) 有显式 'question' 字段。 # B) 无 'question', 问题在 conversation 第一条 role=user 的 content 里 # (assistant 那条是答案, 绝不取, 避免泄露)。 qtext = (it.get("question") or "").strip() if not qtext: conv = it.get("conversation") if isinstance(conv, list): for turn in conv: if isinstance(turn, dict) and turn.get("role") == "user": qtext = (turn.get("content") or "").strip() break if qtext: rec["questions"].append({ "qid": str(it.get("qa_id", "")), "question": qtext, }) clips: List[dict] = [] for (video_uuid, cs, ce), rec in agg.items(): seg0 = rec["segment_uuids"][0] if rec["segment_uuids"] else "noseg" # 用 video + 区间(整数秒) 作为稳定唯一键, 避免同视频多 clip 互相覆盖 clip_id = f"{video_uuid}_{int(round(cs))}_{int(round(ce))}" clips.append({ "id": clip_id, "video_uuid": video_uuid, "clip_start_time": cs, "clip_end_time": ce, "segment_uuid": seg0, "segment_uuids": rec["segment_uuids"], "n_qa": rec["n_qa"], "questions": rec.get("questions", []), }) # 稳定排序: 先 video, 再起始时间 clips.sort(key=lambda c: (c["video_uuid"], c["clip_start_time"])) return clips # ===================================================================== # Per-sample wrapper —— 仿 ovobench process_one_video_async, 改路径 + prompt # ===================================================================== def process_one_video_async( video_data: dict, hyper_vg: HyperVideoGraph, args, llm_timer: Optional[LLMTimer] = None, ) -> tuple: """与 ovobench_async_processing.process_one_video_async 同契约, 仅: * 视频路径用 full_scale_2fps_max384/{uuid}.mp4 * caption_prompt_template 传 FRAME_CAPTION_WINDOW_ESTP_PROMPT * 输出目录 estp_hyper/{uuid}_{model} 其余(async pipeline / 落盘 frame_captions.json + hypergraph.json)全复用。 返回 (did_work, async_stats_or_None)。 建图单位为 clip 区间: video_data 含 video_uuid + clip_start_time/clip_end_time, working_dir 用 clip 粒度的 ``id`` 区分(同视频多 clip 不会互相覆盖), 并把 clip 区间通过 clip_start_sec/clip_end_sec 传给底层 sampler, 只对该时间窗采帧。""" clip_id = video_data["id"] video_uuid = video_data.get("video_uuid", clip_id) clip_start = video_data.get("clip_start_time") clip_end = video_data.get("clip_end_time") working_dir = ( f"{args.save_root}/{args.datasets_type}/{clip_id}_{args.caption_model_name}" ) hypergraph_path = os.path.join(working_dir, "hypergraph.json") # 断点续建: 仅当 hypergraph.json 存在【且非空壳(>1KB)】才算已建好。 # 修(2026-06-26): 旧版只判 exists, 把 190B 空壳(之前 vllm 中断留下)误判已完成而跳过。 if os.path.exists(hypergraph_path) and os.path.getsize(hypergraph_path) > 1000: logger.info(f"跳过 id={clip_id}(hypergraph.json 已建好)") return False, None video_path = os.path.join(args.video_path, f"{video_uuid}.mp4") if not os.path.exists(video_path): logger.error(f" 视频不存在: {video_path}") return False, None os.makedirs(working_dir, exist_ok=True) _reset_hyper_vg_working_dir(hyper_vg, working_dir) # ------------------------------------------------------------------ # q-aware 建图(--qaware): ESTP 问题在视频开始前即给出, 故合规。 # * caption: 用带 {questions_block} 的 q-aware 模板 + question_with_option。 # * fact : 通过 forward_questions 注入 dataset_mode=estpbench_qaware 的 prompt。 # 非 qaware(默认): 完全保持原行为(空问题 + 原 ESTP 模板 + estpbench)。 # ------------------------------------------------------------------ qaware = getattr(args, "qaware", False) clip_questions = video_data.get("questions", []) or [] if qaware and clip_questions: # 该 clip 的全部开放式 question 拼成一个 block(无 options, 不泄露答案)。 q_with_opts = "\n".join( q.get("question", "") for q in clip_questions if q.get("question") ) try: hyper_vg.hypergraph_builder._config.forward_questions = clip_questions hyper_vg.hypergraph_builder._fact_extractor._forward_questions = clip_questions except Exception as e: logger.warning(f" [qaware] 注入 forward_questions 失败: {e}") # caption_prompt_version=v2: GT 对齐版(第一人称 I + dense 秒级锚点 + 短事实句), # 输出 {"dense_caption":..., "description":...}, 解析端已加别名兼容。默认 v1 不变。 if getattr(args, "caption_prompt_version", "v1") == "v2": caption_template = FRAME_CAPTION_WINDOW_ESTP_QAWARE_V2_PROMPT else: caption_template = FRAME_CAPTION_WINDOW_ESTP_QAWARE_PROMPT else: q_with_opts = "" caption_template = FRAME_CAPTION_WINDOW_ESTP_PROMPT if llm_timer is not None: llm_timer.reset() loop = always_get_an_event_loop() try: async_stats = loop.run_until_complete(_run_one_video_async( hyper_vg=hyper_vg, video_path=video_path, # q-aware 时把该 clip 问题喂进 caption(填 {questions_block}); 否则空。 question_with_option=q_with_opts, interval_seconds=args.interval_seconds, window_frames=args.window_frames, max_new_tokens=args.max_new_tokens, day_num=1, # 关键: 注入 ESTP prompt(_run_one_video_async 在 batch 模式下 # 把非 None 的 caption_prompt_template 作为最高优先级模板使用) caption_prompt_template=caption_template, frame_captions_out_path=os.path.join(working_dir, "frame_captions.json"), caption_mode=args.caption_mode, per_frame_concurrency=args.per_frame_concurrency, llm_timer=llm_timer, caption_max_image_side=getattr(args, "caption_max_image_side", 0), caption_jpeg_quality=getattr(args, "caption_jpeg_quality", 85), use_fast_prompt=False, caption_concurrency=getattr(args, "caption_concurrency", 1), pipeline_mode=getattr(args, "pipeline_mode", "v1"), # 只对该 clip 的时间窗 [clip_start, clip_end] 采帧, 时间轴不平移 clip_start_sec=clip_start, clip_end_sec=clip_end, )) # ---------------------------------------------------------------- # 关键修复: _run_one_video_async 的 save_fn 只调用 save_hypergraph(), # 它落盘的是「空的」dual_index(建图阶段从不计算 embedding, embed=0calls), # 导致 hypergraph_embeddings.npz files=[] / 向量总数=0, 检索完全失效。 # # OVO 路径之所以 npz 非空, 是因为它建完图后还会跑 retrieval, 由 # retrieve()->ensure_retrieval_index() 惰性 rebuild+save 填充 npz。 # ESTP 是「只建图」流程, 没有后续 retrieval, 故必须在建图收尾时主动 # 触发一次 embedding 计算并落盘。ensure_retrieval_index() 内部: # index_dirty(建图已置 True) -> dual_index.rebuild(hypergraph) # -> 对 facts/episodes/topics 调 embedding_func(随 default_llm_config, # 与 OVO 一致) -> save() 覆盖 npz。 # 该调用仅作用于本 clip 的 hyper_vg(已 _reset 到本 clip 的 working_dir), # 不触及 OVO 共享流水, 不会回归 OVO 行为。 loop.run_until_complete(hyper_vg.ensure_retrieval_index()) emb_stats = hyper_vg.dual_index._emb_index._embeddings.get_stats() logger.info( f" [Embed] id={clip_id} 建图后已计算并落盘 embedding, stats={emb_stats}" ) return True, async_stats except Exception as e: logger.error(f" 建图失败 id={clip_id}: {e}") return False, None finally: clear_gpu_memory() # ===================================================================== # Main —— 仿 ovobench main, 改数据加载 + 默认路径 # ===================================================================== def main(): parser = argparse.ArgumentParser() parser.add_argument( "--data_path", type=str, default="/mnt/tokyo-ai/gst/ESTP-IT/ESTP-Bench/estp_dataset/estp_bench_sq.json", ) parser.add_argument( "--video_path", type=str, default="/mnt/tokyo-ai/gst/ESTP-IT/ESTP-Bench/full_scale_2fps_max384", ) parser.add_argument( "--save_root", type=str, default="/mnt/tokyo-ai/gst/GST_EGOSERVE/all_results", ) parser.add_argument( "--caption_model_name", type=str, default="qwen_api", help="qwen_api (DashScope) / qwen_vllm (本地或远程 vLLM server)", ) parser.add_argument("--qwen_api_model", type=str, default="qwen-vl-max") parser.add_argument( "--vllm_base_url", type=str, default=os.environ.get("VLLM_BASE_URL", "http://localhost:8000/v1"), help="vLLM OpenAI 兼容端点; 仅当 --caption_model_name=qwen_vllm 时使用。", ) parser.add_argument( "--vllm_model_name", type=str, default=os.environ.get("VLLM_MODEL_NAME", "Qwen3-VL-8B-Instruct"), help="必须与 vLLM server 的 --served-model-name 一致。", ) parser.add_argument( "--qwen_api_key", type=str, default="YOUR_API_KEY", ) parser.add_argument("--datasets_type", type=str, default="estp_hyper") parser.add_argument("--cuda", type=str, default="0") # ESTP 视频已是 2fps; window_frames=5 => 每窗 ~2.5s, 与 ovobench 默认一致。 parser.add_argument("--interval_seconds", type=float, default=2.0) parser.add_argument("--window_frames", type=int, default=5) parser.add_argument("--max_new_tokens", type=int, default=2048) parser.add_argument("--caption_mode", type=str, default="batch", choices=["batch", "per_frame"]) parser.add_argument("--per_frame_concurrency", type=int, default=5) parser.add_argument("--qaware", action="store_true", help="带问题建图: 把该 clip 的 question 喂进 caption+fact prompt " "(ESTP 问题在视频前即给出, 合规)。默认关闭=原开放式建图。") parser.add_argument("--caption_prompt_version", type=str, default="v1", choices=["v1", "v2"], help="qaware caption prompt 版本: v1=第三人称详述(默认); " "v2=GT对齐版(第一人称I+dense秒级锚点+短事实句)。仅 --qaware 时生效。") parser.add_argument("--only_uuids", type=str, default=None, help="仅处理指定 video_uuid, 逗号分隔(小批量验证用)") parser.add_argument("--limit", type=int, default=0, help="若 >0, 只处理前 N 个未完成视频(小批量验证用)") parser.add_argument( "--caption_max_image_side", type=int, default=0, help="若 >0 把每帧缩放至 max(W,H)<=该值。ESTP 已是 max384, 默认 0 不缩放。", ) parser.add_argument("--caption_jpeg_quality", type=int, default=85) parser.add_argument( "--caption_concurrency", type=int, default=1, help="同时在飞行的 caption API 调用数。1=串行; 本地 vLLM 可上 4-8。", ) parser.add_argument( "--pipeline_mode", type=str, default="v1", choices=["v1", "v2", "v3"], help="v1=plan A / v2=plan E / v3=plan B(同 ovobench 含义)。", ) parser.add_argument( "--openai_api_key", type=str, default=os.environ.get("OPENAI_API_KEY", "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"), ) parser.add_argument( "--timing_out_path", type=str, default=None, help="若设置, 输出每个 video 的耗时 + async 各 stage 耗时 JSON。", ) parser.add_argument("--only_ids", type=str, default=None, help="仅处理指定 clip id(含区间, 如 uuid_0_30), 逗号分隔" "(冒烟验证用, 比 --only_uuids 更精细)") args = parser.parse_args() os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda # 只在传了真实 key 时覆盖; 硬编码错 default(结尾6QcA)或没 key 时, 从 .env 取对 key if args.openai_api_key and not args.openai_api_key.endswith("6QcA"): os.environ["OPENAI_API_KEY"] = args.openai_api_key if (not os.environ.get("OPENAI_API_KEY")) or os.environ.get("OPENAI_API_KEY", "").endswith("6QcA"): from dotenv import load_dotenv load_dotenv("/mnt/tokyo-ai/gst/GST_EGOSERVE/.env") # 1. 加载 ESTP clip 列表(建图单位 = 唯一 clip 区间, 每个 clip 一张超图) all_videos = load_estp_clips(args.data_path) n_videos = len({c["video_uuid"] for c in all_videos}) logger.info( f"共加载 {len(all_videos)} 个唯一 clip 区间(来自 {n_videos} 个 video), " f"QA 总数={sum(c['n_qa'] for c in all_videos)}" ) if args.only_uuids: # 按 video_uuid 过滤(一个 video 可能含多个 clip) wanted = {s.strip() for s in args.only_uuids.split(",") if s.strip()} all_videos = [x for x in all_videos if x["video_uuid"] in wanted] logger.info(f"按 --only_uuids 过滤后剩余 {len(all_videos)} 个 clip") if args.only_ids: wanted_ids = {s.strip() for s in args.only_ids.split(",") if s.strip()} all_videos = [x for x in all_videos if x["id"] in wanted_ids] logger.info(f"按 --only_ids 过滤后剩余 {len(all_videos)} 个 clip") # 跳过已建图(按 clip 粒度的 id) unprocessed = [] for item in all_videos: hg_path = os.path.join( args.save_root, args.datasets_type, f"{item['id']}_{args.caption_model_name}", "hypergraph.json", ) # 修(2026-06-26): 空壳(<=1KB)视为未建, 需重建 (旧版只判 exists 把空壳误跳过)。 if not (os.path.exists(hg_path) and os.path.getsize(hg_path) > 1000): unprocessed.append(item) skipped = len(all_videos) - len(unprocessed) if skipped > 0: logger.info(f"跳过已完成 {skipped} 个 clip, 剩余 {len(unprocessed)} 个") if args.limit and args.limit > 0: unprocessed = unprocessed[: args.limit] logger.info(f"按 --limit 截断到前 {len(unprocessed)} 个 clip") if not unprocessed: logger.info("全部已处理完毕") return # 2. 初始化 HyperVideoGraph(一次性, 跨视频共享; 逐视频 _reset working_dir) init_working_dir = os.path.join( args.save_root, args.datasets_type, f"_init_{args.caption_model_name}" ) os.makedirs(init_working_dir, exist_ok=True) # q-aware 时用 estpbench_qaware(仅 fact_extractor 走 q-aware prompt, # segmenter/topic_aggregator 经 hypergraph_builder 别名仍按 estpbench 行为)。 _ds_mode = "estpbench_qaware" if getattr(args, "qaware", False) else "estpbench" hyper_cfg = HyperVideoConfig( dataset_mode=_ds_mode, # ESTP 专用三层 prompt(fact/episode/topic) caption_granularity="per_window", boundary_strategy="stream", caption_window_seconds=float(args.window_frames) * args.interval_seconds, caption_frame_interval_sec=args.interval_seconds, caption_mode=args.caption_mode, ) logger.info( f"模式: caption_mode={args.caption_mode}, per_window, stream (V2 async), " f"caption prompt=FRAME_CAPTION_WINDOW_ESTP_PROMPT" ) hyper_vg = HyperVideoGraph( working_dir=init_working_dir, llm=default_llm_config, hyper_config=hyper_cfg, ) logger.info(f"加载 caption model: {args.caption_model_name}") if args.caption_model_name == "qwen_api": hyper_vg.load_caption_model( "qwen_api", api_model_name=args.qwen_api_model, api_key=args.qwen_api_key, ) elif args.caption_model_name == "qwen_vllm": hyper_vg.load_caption_model( "qwen_vllm", vllm_base_url=args.vllm_base_url, vllm_model_name=args.vllm_model_name, ) logger.info(f" vllm_base_url={args.vllm_base_url} model={args.vllm_model_name}") else: hyper_vg.load_caption_model(args.caption_model_name) logger.info( f"HyperVideoGraph 初始化完成, " f"stats={hyper_vg.hypergraph_builder.hypergraph.get_stats()}" ) llm_timer = LLMTimer() # 3. 逐 clip 建图 t_all = time.time() ok_count = 0 timings: List[dict] = [] for idx, video_data in enumerate(unprocessed): t0 = time.time() vid = video_data["id"] logger.info( f"[{idx+1}/{len(unprocessed)}] id={vid} " f"clip=[{video_data['clip_start_time']:.1f}, {video_data['clip_end_time']:.1f}]s " f"n_qa={video_data['n_qa']} seg={video_data['segment_uuid']}" ) try: did_work, async_stats = process_one_video_async( video_data, hyper_vg, args, llm_timer=llm_timer, ) if did_work: ok_count += 1 except Exception as e: logger.error(f" 样本 id={vid} 处理异常: {e}") timings.append({"id": vid, "error": str(e), "elapsed_s": time.time() - t0}) continue elapsed = time.time() - t0 per_video_llm = llm_timer.summary() logger.info( f"[{idx+1}/{len(unprocessed)}] id={vid} 耗时 {elapsed:.1f}s | " f"LLM: best={per_video_llm['best_model']['n_calls']}calls/{per_video_llm['best_model']['total_s']:.1f}s " f"cheap={per_video_llm['cheap_model']['n_calls']}calls/{per_video_llm['cheap_model']['total_s']:.1f}s " f"embed={per_video_llm['embedding']['n_calls']}calls/{per_video_llm['embedding']['total_s']:.1f}s" ) timings.append({ "id": vid, "elapsed_s": elapsed, "llm_stats": per_video_llm, "async_stats": async_stats.as_dict() if async_stats is not None else None, }) total = time.time() - t_all logger.info( f"\n{'='*80}\nESTP 建图完成 (async): 成功 {ok_count}/{len(unprocessed)}, " f"总耗时 {total:.1f}s ({total/60:.1f}min)\n{'='*80}" ) if args.timing_out_path: try: os.makedirs(os.path.dirname(args.timing_out_path) or ".", exist_ok=True) with open(args.timing_out_path, "w", encoding="utf-8") as f: json.dump({ "datasets_type": args.datasets_type, "total_seconds": total, "ok_count": ok_count, "total_videos": len(unprocessed), "per_video": timings, }, f, ensure_ascii=False, indent=2) logger.info(f"Timing summary -> {args.timing_out_path}") except Exception as e: logger.error(f"保存 timing 失败: {e}") if __name__ == "__main__": main()