Download code/estp_async_processing.py from SitongGong/paper_final_results: direct link, hf CLI and curl.
- Browser
- Download file 26.4 kB
-
https://huggingface.co/datasets/SitongGong/paper_final_results/resolve/main/code/estp_async_processing.py
- Command line
-
hf download hf://datasets/SitongGong/paper_final_results/code/estp_async_processing.py
-
curl -L -o estp_async_processing.py https://huggingface.co/datasets/SitongGong/paper_final_results/resolve/main/code/estp_async_processing.py
26.4 kB
| """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() | |