"""EgoLife 建图入口 — 以参与者为单位扫时间线 + 建三层超图 + 抽积累事件 与 streamingbench / ovobench processing 脚本的关键差异: 1. 视频源是**一个参与者一整天(或跨多天)的 30s 短视频序列**,不是单个 mp4 2. 每段 mp4 独立抽帧(默认 3s/帧 → 10 帧),每段视为一个"caption window", VLM 调用时注入这段 mp4 的**绝对时间范围**,确保 caption 带真实时间戳 3. 跨 session_gap 时强制插 episode 边界(builder.flush()), 并在 AccumulativeEventLog 追加 'session_gap' 事件 4. HyperVideoConfig.dataset_mode="egolife" 激活 EgoLife caption prompt + 积累事件并行抽取(drink / sit_start/stop / phone_use_start/stop) 用法: # DashScope qwen-vl-max API caption,A1_JAKE 全量 python -m hypervideo.egolife_hyper_processing \\ --egolife_root /mnt/tokyo-ai/gst/EgoLife/egolife \\ --participant A1_JAKE \\ --save_root /mnt/tokyo-ai/gst/GST_EGOSERVE/all_results \\ --datasets_type egolife_hyper_v2 \\ --caption_model qwen_api \\ --qwen_api_model qwen-vl-max \\ --qwen_api_key sk-... # 只跑 DAY1 ... --days DAY1 # 本地 Qwen3-VL-8B-Instruct(显存足够时) ... --caption_model qwenvl_3_8b_instruct --cuda 0 """ from __future__ import annotations import argparse import asyncio import base64 import gc import io import json import logging import os import sys import time from dataclasses import asdict from typing import Dict, List, Optional, Tuple import cv2 import numpy as np import torch from PIL import Image sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) from videorag._llm import ( LLMConfig, openai_embedding, gpt_4o_mini_complete, ) from videorag._utils import always_get_an_event_loop from hypervideo.hyper_video_graph import HyperVideoGraph from hypervideo.config import HyperVideoConfig from hypervideo.prompts.frame_caption_prompt import ( FRAME_CAPTION_WINDOW_EGOLIFE_PROMPT, FRAME_CAPTION_WINDOW_EGOLIFE_WITH_PRIOR_PROMPT, ) from hypervideo.extractors.egolife_timeline import ( ParticipantTimeline, VideoSegment, SessionGap, abs_time_str, ) from hypervideo.types import AccumulativeEvent logging.basicConfig( level=logging.INFO, format='[%(asctime)s] %(levelname)s: %(message)s', ) logger = logging.getLogger(__name__) # ============================================================ # LLM 配置 # ============================================================ default_llm_config = LLMConfig( embedding_func_raw=openai_embedding, embedding_model_name="text-embedding-3-small", embedding_dim=1536, embedding_max_token_size=8192, embedding_batch_num=32, embedding_func_max_async=16, query_better_than_threshold=0.2, best_model_func_raw=gpt_4o_mini_complete, best_model_name="gpt-4.1-mini", best_model_max_token_size=32768, best_model_max_async=16, cheap_model_func_raw=gpt_4o_mini_complete, cheap_model_name="gpt-4.1-mini", cheap_model_max_token_size=32768, cheap_model_max_async=16, ) # ============================================================ # 工具: 抽帧 / 编码 # ============================================================ def _sample_frames_middle( video_path: str, interval_sec: float, max_long_edge: Optional[int] = 560, ) -> List[np.ndarray]: """按 interval 取每段中点帧,返回 RGB np.ndarray 列表。""" cap = cv2.VideoCapture(video_path) fps = cap.get(cv2.CAP_PROP_FPS) n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) duration = n_frames / fps if fps > 0 else 0.0 if duration <= 0: cap.release() return [] num_intervals = int(np.ceil(duration / interval_sec)) offsets = [min(duration - 1e-3, i * interval_sec + interval_sec / 2.0) for i in range(num_intervals)] frames: List[np.ndarray] = [] for t in offsets: cap.set(cv2.CAP_PROP_POS_MSEC, t * 1000.0) ok, bgr = cap.read() if not ok: continue rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB) if max_long_edge is not None: h, w = rgb.shape[:2] scale = max_long_edge / max(h, w) if scale < 1.0: rgb = cv2.resize( rgb, (int(w * scale), int(h * scale)), interpolation=cv2.INTER_AREA, ) frames.append(rgb) cap.release() return frames def _np_to_base64_jpeg(arr_rgb: np.ndarray, quality: int = 85) -> str: buf = io.BytesIO() Image.fromarray(arr_rgb).save(buf, format="JPEG", quality=quality) return base64.b64encode(buf.getvalue()).decode("utf-8") def _safe_json_parse(text: str) -> Optional[dict]: """剥 ```json``` 围栏 / 取首个 {...}; 解析失败返回 None。""" import re as _re try: return json.loads(text) except Exception: pass m = _re.search(r"```(?:json)?\s*\n(.*?)\n?```", text, _re.DOTALL | _re.IGNORECASE) if m: try: return json.loads(m.group(1).strip()) except Exception: pass m = _re.search(r"(\{.*\})", text, _re.DOTALL) if m: try: return json.loads(m.group(1).strip()) except Exception: pass return None # ============================================================ # EgoLife caption: 跨文件累积 30s 窗口 → 一次 VLM 调用 # ============================================================ def _caption_accumulated_window( hyper_vg: HyperVideoGraph, window_frames_b64: List[str], window_frame_meta: List[dict], # 每项: {day, start_sec_in_day, end_sec_in_day} interval_sec: float, desc_min_sentences: int, desc_max_sentences: int, max_new_tokens: int, max_retries: int = 3, prior_frame_captions: Optional[List[str]] = None, ) -> Optional[dict]: """对累积到的一窗帧做一次 VLM 调用。 Args: window_frames_b64: base64 帧列表 (10 帧/30s/3s-interval 时为 10 张) window_frame_meta: 每帧的元数据 [{day, start_sec_in_day, end_sec_in_day}, ...] Returns: { "dense_caption": {"DAYd-HH:MM:SS-HH:MM:SS": "", ...}, "description": "", } """ # 时间戳的转换 if not window_frames_b64: return None num_frames = len(window_frames_b64) first = window_frame_meta[0] last = window_frame_meta[-1] abs_start_str = abs_time_str(first["day"], first["start_sec_in_day"]) abs_end_str = abs_time_str(last["day"], last["end_sec_in_day"]) window_seconds = int(round(last["end_sec_in_day"] - first["start_sec_in_day"] + (last["day"] - first["day"]) * 86400)) window_seconds = max(window_seconds, int(interval_sec)) # prompt 里要示范给模型"第一个/最后一个"帧的时间戳长什么样 first_ts_example = abs_time_str(first["day"], first["start_sec_in_day"]) last_ts_example = abs_time_str(last["day"], last["start_sec_in_day"]) common_kwargs = dict( window_seconds=window_seconds, abs_start=abs_start_str, abs_end=abs_end_str, num_frames=num_frames, interval_sec=int(interval_sec), desc_min=desc_min_sentences, desc_max=desc_max_sentences, first_ts_example=first_ts_example, last_ts_example=last_ts_example, ) # 有 prior 走 with-prior 版; 无 prior 或首窗走原版 if prior_frame_captions: prior_text = "\n".join(prior_frame_captions) prompt = FRAME_CAPTION_WINDOW_EGOLIFE_WITH_PRIOR_PROMPT.format( prior_frame_context=prior_text, **common_kwargs, ) else: prompt = FRAME_CAPTION_WINDOW_EGOLIFE_PROMPT.format(**common_kwargs) # 预先算每帧的"期望时间戳 key"(整数秒向下) → meta 映射, 用来匹配模型输出的 key # 同时保留按帧序号兜底(模型仍输出 "0"/"1" 时) expected_ts_to_meta: Dict[str, dict] = {} for fi, meta in enumerate(window_frame_meta): ts_key = abs_time_str(meta["day"], meta["start_sec_in_day"]) # DAYd-HH:MM:SS (整数秒) expected_ts_to_meta[ts_key] = meta def _meta_from_key(raw_key: str) -> Optional[dict]: """把模型输出的 key 映射到 window_frame_meta 中的一项。 支持: * "DAYd-HH:MM:SS" → 直接匹配 expected_ts_to_meta * "0" / "1" / ... → 按索引 fallback * "DAYd-HH:MM:SS — xxx" → 只取时间戳部分 """ # 整数索引兜底 try: fi = int(raw_key) if 0 <= fi < num_frames: return window_frame_meta[fi] except ValueError: pass # 时间戳匹配(允许 key 里有 — 或冒号后缀) import re as _re m = _re.match(r"\s*(DAY\d+-\d{2}:\d{2}:\d{2})", raw_key) if m: ts = m.group(1) if ts in expected_ts_to_meta: return expected_ts_to_meta[ts] # 容忍 ±2s 偏移 def _ts_to_sec(s: str) -> int: mm = _re.match(r"DAY(\d+)-(\d+):(\d+):(\d+)", s) return int(mm.group(2))*3600 + int(mm.group(3))*60 + int(mm.group(4)) if mm else -1 target_sec = _ts_to_sec(ts) best = None best_diff = 999 for cand, meta_c in expected_ts_to_meta.items(): d = abs(_ts_to_sec(cand) - target_sec) if d < best_diff: best_diff = d best = meta_c if best is not None and best_diff <= 2: return best return None # 多次尝试生成caption for retry in range(max_retries): try: text = hyper_vg.mllm_response( hyper_vg.video_llm, hyper_vg.processor, prompt, None, base64_frames=window_frames_b64, max_new_tokens=max_new_tokens, has_image=True, ) # 提取并检查cpation的格式 parsed = _safe_json_parse(text) if not (isinstance(parsed, dict) and "frames" in parsed and isinstance(parsed["frames"], dict)): logger.warning(f" [Caption] invalid JSON retry {retry+1}/{max_retries}") continue desc = str(parsed.get("description") or "").strip() if not desc: logger.warning(f" [Caption] empty description retry {retry+1}/{max_retries}") continue # 对dense_caption的时间戳进行转换 dense_caption: Dict[str, str] = {} seen_meta_ids = set() for raw_key, cap_text in parsed["frames"].items(): meta = _meta_from_key(raw_key) if meta is None: continue mid = (meta["day"], meta["start_sec_in_day"]) if mid in seen_meta_ids: continue # 重复 key → 取第一次出现 seen_meta_ids.add(mid) # 下游 hypergraph_builder 的 dense_caption key 必须是 "DAY{d}-start-end" 格式 f_start_str = abs_time_str(meta["day"], meta["start_sec_in_day"]).split("-", 1)[1] f_end_str = abs_time_str(meta["day"], meta["end_sec_in_day"]).split("-", 1)[1] down_key = f"DAY{meta['day']}-{f_start_str}-{f_end_str}" dense_caption[down_key] = str(cap_text) if not dense_caption: logger.warning(f" [Caption] empty dense_caption retry {retry+1}/{max_retries}") continue return {"dense_caption": dense_caption, "description": desc} except Exception as e: logger.error(f" [Caption] VLM error retry {retry+1}/{max_retries}: {e}") continue return None # ============================================================ # Checkpoint / Resume 工具 # ============================================================ PROGRESS_FILENAME = "progress.json" FRAME_CAPTIONS_FILENAME = "frame_captions.json" def _empty_progress() -> Dict: return { "participant_id": None, # 已被消费(成 caption + flush 进 hypergraph)的帧 key 集合, 序列化为 list # key 格式: "DAYd-start_sec_in_day-end_sec_in_day" (1 位小数, 字符串方便 JSON) "processed_frame_keys": [], # 仍保留 last_seg_index / last_day_completed 作日志展示, 不再用于跳过文件 "last_seg_index": -1, "last_day_completed": 0, # 当前未 flush 窗口的状态: 仅存帧 meta + prior, 不存 base64; resume 时从源 mp4 重抽 "cur_window_state": { "cur_frame_meta": [], # [{day, start_sec_in_day, end_sec_in_day, src_file, src_offset_sec}, ...] "prev_tail_captions": [], "window_start_day": None, "window_start_sec": None, "last_frame_end_sec_absolute": None, }, "updated_at": None, } def _frame_key(meta: Dict) -> str: """从帧 meta 构造稳定 key (string for JSON)。""" return ( f"DAY{int(meta['day'])}-" f"{float(meta['start_sec_in_day']):.1f}-" f"{float(meta['end_sec_in_day']):.1f}" ) def _load_progress(working_dir: str) -> Dict: """读取 progress.json;若不存在返回空结构。""" p = os.path.join(working_dir, PROGRESS_FILENAME) if not os.path.isfile(p): return _empty_progress() try: with open(p) as f: d = json.load(f) # 向后兼容: 旧 progress 缺字段补默认 if "cur_window_state" not in d: d["cur_window_state"] = _empty_progress()["cur_window_state"] if "processed_frame_keys" not in d: d["processed_frame_keys"] = [] return d except Exception as e: logger.warning(f"[resume] progress.json corrupt, starting fresh: {e}") return _empty_progress() def _atomic_write_json(path: str, data: Dict): """原子写: 先写 tmp 再 rename,避免中断导致文件半残。""" tmp = path + ".tmp" with open(tmp, "w", encoding="utf-8") as f: json.dump(data, f, ensure_ascii=False, indent=2, default=str) os.replace(tmp, path) def _save_checkpoint( hyper_vg: HyperVideoGraph, working_dir: str, progress: Dict, frame_captions: List[dict], window_descriptions: List[dict], interval_sec: float, participant_id: str, cur_window_state: Optional[Dict] = None, ): """保存全部状态: hypergraph.json + builder_state.json + frame_captions.json + progress.json。 注意: * hyper_vg.save_hypergraph() 会同时存 hypergraph.json 和 builder_state.json (含 segmenter buffer + chunk_descriptions, 即"已生成 caption 但还没成 episode 的帧") * cur_window_state 存"caption 还没生成的 in-flight 窗口" -> 仅 meta, 不存 base64 """ # 1) hypergraph + builder_state(含 segmenter buffer) try: hyper_vg.save_hypergraph() except Exception as e: logger.error(f"[ckpt] save_hypergraph failed: {e}") # 2) frame_captions (整个重写,保证和 hypergraph 一致) fc_path = os.path.join(working_dir, FRAME_CAPTIONS_FILENAME) try: _atomic_write_json(fc_path, { "participant_id": participant_id, "interval_seconds": interval_sec, "frame_captions": frame_captions, "window_descriptions": window_descriptions, }) except Exception as e: logger.error(f"[ckpt] save frame_captions failed: {e}") # 3) progress.json 原子写 (含 cur_window_state) if cur_window_state is not None: progress["cur_window_state"] = cur_window_state progress["updated_at"] = time.strftime("%Y-%m-%d %H:%M:%S") try: _atomic_write_json(os.path.join(working_dir, PROGRESS_FILENAME), progress) except Exception as e: logger.error(f"[ckpt] save progress failed: {e}") def _load_existing_frame_captions(working_dir: str) -> Tuple[List[dict], List[dict]]: """resume 时把旧 frame_captions.json 读回来,保证后续追加不丢数据。""" p = os.path.join(working_dir, FRAME_CAPTIONS_FILENAME) if not os.path.isfile(p): return [], [] try: with open(p) as f: d = json.load(f) return d.get("frame_captions", []) or [], d.get("window_descriptions", []) or [] except Exception as e: logger.warning(f"[resume] frame_captions corrupt, ignoring: {e}") return [], [] # ============================================================ # 主循环: 按「天」分批建图 + 增量 checkpoint + resume # ============================================================ def run_participant_construction( hyper_vg: HyperVideoGraph, timeline: ParticipantTimeline, working_dir: str, day_filter: Optional[List[int]] = None, interval_sec: float = 3.0, window_seconds: float = 30.0, gap_threshold_sec: float = 60.0, desc_min_sentences: int = 2, desc_max_sentences: int = 3, max_new_tokens: int = 2048, max_long_edge: int = 560, checkpoint_every_windows: int = 10, ): """EgoLife 流式建图 —— 跨文件 30s 窗口累积 + 每 10 个 window 存盘。 关键行为(参考 videorag/egograph_retrieval_optimize_.streaming_graph_construction): * 帧按 interval_sec 在每个 30s mp4 内部抽样 (默认 3s/frame × 10 frame = 30s) * 但**帧不与文件绑定** —— 帧 append 到全局 current_window_frames 列表 * 窗口触发条件(任一成立 → 送 VLM caption → 喂 hypergraph_builder → 重置窗口): (1) window_duration >= window_seconds (默认 30s 满了) (2) day_changed (跨天) (3) is_gap (相邻帧间隔 >= gap_threshold_sec) * 跨天 / 跨 gap 触发时,额外在 hypergraph 写一条 session_gap 积累事件 * 每 checkpoint_every_windows 个成功 window 落盘一次 (hypergraph + progress + frame_captions) * resume: progress.json 记录已处理的文件路径,重跑时跳过(粗粒度,以文件为单位) * KeyboardInterrupt / 异常: finally 分支再保存一次 progress.json schema: { participant_id, processed_segment_paths (list of file paths fully consumed), last_seg_index, last_day_completed, updated_at, } """ loop = always_get_an_event_loop() # ---- 1) 读 checkpoint ---- progress = _load_progress(working_dir) if progress["participant_id"] not in (None, timeline.participant_id): logger.warning( f"[resume] progress.json participant mismatch " f"({progress['participant_id']} vs {timeline.participant_id}) — overwriting" ) progress = _empty_progress() progress["participant_id"] = timeline.participant_id # 帧级 resume key 集合(已成 caption 并 flush 进 hypergraph 的帧) processed_frame_keys: set = set(progress.get("processed_frame_keys") or []) all_frame_captions, window_descriptions = _load_existing_frame_captions(working_dir) try: hyper_vg.hypergraph_builder.reset_timing() except Exception: pass # resume 容灾: 若上次中断在 _process_completed_episode 中, 这里重做该 episode try: loop.run_until_complete( hyper_vg.hypergraph_builder.recover_pending_episode_if_any() ) except Exception as e: logger.warning(f"[recover] recover_pending_episode_if_any failed: {e}") # ---- 2) day filter + 排序 ---- segs_all: List[Tuple[int, VideoSegment]] = [] for idx, seg in enumerate(timeline.segments): if day_filter is not None and seg.day not in day_filter: continue segs_all.append((idx, seg)) segs_all.sort(key=lambda x: (x[1].day, x[1].start_sec_in_day)) total_segs = len(segs_all) # already_done 现在用 processed_frame_keys 数量做粗略统计 (不再以文件为粒度) already_done_frames = len(processed_frame_keys) logger.info( f"[Egolife] participant={timeline.participant_id}, " f"day_filter={day_filter}, total_segs={total_segs}, " f"already_done_frames={already_done_frames}, " f"window_sec={window_seconds}, interval_sec={interval_sec}, " f"gap_threshold={gap_threshold_sec}s" ) # ---- 3) 全局累积 window 状态 (resume 友好) ---- cur_frames_b64: List[str] = [] cur_frame_meta: List[dict] = [] # {day, start_sec_in_day, end_sec_in_day, src_file, src_offset_sec} window_start_day: Optional[int] = None window_start_sec: Optional[float] = None # 以 day 为基准的秒 in day last_frame_end_sec_absolute: Optional[float] = None # 跨天累加 -> day*86400 + end prev_seg_day: Optional[int] = None n_windows_done = 0 n_windows_in_session = 0 processed_in_session = 0 # 上一窗尾部 1-2 条 frame caption(带时间戳前缀),用作下一窗的 naming anchor # 跨天 / 跨 gap 会清空(当 session 重开始时, 旧 prior 不可靠) prev_tail_captions: List[str] = [] N_PRIOR = 2 # ---- 3.5) 从 progress.cur_window_state 恢复未 flush 窗口 ---- cw_state = progress.get("cur_window_state") or {} saved_meta = cw_state.get("cur_frame_meta") or [] if saved_meta: # 重抽 base64 帧: 按 src_file + src_offset_sec 决定从哪个 mp4 读哪一帧 from collections import defaultdict by_src: Dict[str, List[Tuple[int, dict]]] = defaultdict(list) for i, m in enumerate(saved_meta): sf = m.get("src_file") if sf: by_src[sf].append((i, m)) recovered_b64: Dict[int, str] = {} for sf, items in by_src.items(): if not os.path.isfile(sf): logger.warning(f"[resume] saved cur_window references missing file {sf}, skipping its frames") continue try: cap = cv2.VideoCapture(sf) for idx_in_meta, m in items: off = float(m.get("src_offset_sec", 0.0)) cap.set(cv2.CAP_PROP_POS_MSEC, off * 1000.0) ok, bgr = cap.read() if not ok: continue rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB) if max_long_edge is not None: h, w = rgb.shape[:2] scale = max_long_edge / max(h, w) if scale < 1.0: rgb = cv2.resize(rgb, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA) recovered_b64[idx_in_meta] = _np_to_base64_jpeg(rgb) cap.release() except Exception as e: logger.warning(f"[resume] failed to re-decode frames from {sf}: {e}") # 按 saved_meta 顺序重建 cur_frames_b64 for i, m in enumerate(saved_meta): if i in recovered_b64: cur_frames_b64.append(recovered_b64[i]) cur_frame_meta.append(m) if cur_frames_b64: window_start_day = cur_frame_meta[0]["day"] window_start_sec = cur_frame_meta[0]["start_sec_in_day"] last_meta = cur_frame_meta[-1] last_frame_end_sec_absolute = ( (last_meta["day"] - 1) * 86400 + last_meta["end_sec_in_day"] ) prev_tail_captions = list(cw_state.get("prev_tail_captions") or []) logger.info( f"[resume] recovered cur_window: {len(cur_frames_b64)}/{len(saved_meta)} frames " f"+ {len(prev_tail_captions)} prior captions" ) else: prev_tail_captions = list(cw_state.get("prev_tail_captions") or []) if prev_tail_captions: logger.info(f"[resume] recovered prev_tail_captions={len(prev_tail_captions)}") def _absolute_sec(day: int, sec_in_day: float) -> float: return (day - 1) * 86400 + sec_in_day def _snapshot_cur_window_state() -> Dict: """构造可序列化的 cur_window_state(供 progress.json 持久化)。 只存帧 meta + prior + window 起点; 不存 base64 帧 (resume 时用 cv2 重抽)。 """ return { "cur_frame_meta": list(cur_frame_meta), "prev_tail_captions": list(prev_tail_captions), "window_start_day": window_start_day, "window_start_sec": window_start_sec, "last_frame_end_sec_absolute": last_frame_end_sec_absolute, } def _flush_window(reason: str) -> None: """把 cur_frames_b64 + cur_frame_meta 喂给 VLM + hypergraph_builder,然后清空。 同时维护 prev_tail_captions: 成功处理一个 window 后取末尾 N_PRIOR 条 frame caption 作为下一窗的 naming anchor; 跨 session_gap 触发时 caller 会显式清空 prev_tail_captions。 """ nonlocal cur_frames_b64, cur_frame_meta, prev_tail_captions nonlocal window_start_day, window_start_sec, n_windows_done, n_windows_in_session if not cur_frames_b64: return first = cur_frame_meta[0] last = cur_frame_meta[-1] t0 = time.time() caption_dict = _caption_accumulated_window( # 生成caption hyper_vg=hyper_vg, window_frames_b64=cur_frames_b64, window_frame_meta=cur_frame_meta, interval_sec=interval_sec, desc_min_sentences=desc_min_sentences, desc_max_sentences=desc_max_sentences, max_new_tokens=max_new_tokens, prior_frame_captions=prev_tail_captions or None, ) dt = time.time() - t0 if caption_dict is None: # VLM 全部重试失败 — 记录占位条目, 让下游能看见这段是"缺数据", 而不是无声丢失 win_start_str = abs_time_str(first["day"], first["start_sec_in_day"]).split("-", 1)[1] win_end_str = abs_time_str(last["day"], last["end_sec_in_day"]).split("-", 1)[1] failed_span = f"{first['day']}-{win_start_str}-{win_end_str}" logger.error( f" [Window] VLM failed, reason={reason}, span={failed_span}, " f"{len(cur_frames_b64)} frames — skipping (recorded as VLM_FAILED placeholder)" ) window_descriptions.append({ "time_span": failed_span, "description": "[VLM_FAILED]", "vlm_failed": True, "frame_count": len(cur_frames_b64), "trigger_reason": reason, }) cur_frames_b64 = [] cur_frame_meta = [] window_start_day = None window_start_sec = None return win_start_str = abs_time_str(first["day"], first["start_sec_in_day"]).split("-", 1)[1] win_end_str = abs_time_str(last["day"], last["end_sec_in_day"]).split("-", 1)[1] win_time_span = f"{first['day']}-{win_start_str}-{win_end_str}" logger.info( f" [Window#{n_windows_done+1}] reason={reason}, {win_time_span}, " f"{len(cur_frames_b64)} frames, {dt:.1f}s, " f"prior={len(prev_tail_captions)}" ) for fk, fv in caption_dict["dense_caption"].items(): all_frame_captions.append({"time_span": fk, "caption": fv}) window_descriptions.append({ "time_span": win_time_span, "description": caption_dict["description"], }) # 更新 prev_tail_captions: 取本窗 dense_caption 字典的末尾 N_PRIOR 条 dc = caption_dict["dense_caption"] sorted_keys = sorted(dc.keys()) # key = "DAYd-HH:MM:SS-HH:MM:SS", 按字典序≈时间序 tail_keys = sorted_keys[-N_PRIOR:] prev_tail_captions = [f"[{k}] {dc[k]}" for k in tail_keys] # 构造episode,以及建图等操作 try: loop.run_until_complete( hyper_vg.hypergraph_builder.process_window_caption_v2( caption_dict=caption_dict, time_span=win_time_span, day_num=first["day"], ) ) except Exception as e: logger.error(f" [Hyper] process_window_caption_v2 failed: {e}") # 帧级 progress: 把窗口内所有帧 key 加进 processed_frame_keys for m in cur_frame_meta: processed_frame_keys.add(_frame_key(m)) progress["processed_frame_keys"] = list(processed_frame_keys) n_windows_done += 1 n_windows_in_session += 1 # 重置 window cur_frames_b64 = [] cur_frame_meta = [] window_start_day = None window_start_sec = None # 每 N window 落盘 保存之前构造好的超图 if n_windows_in_session % checkpoint_every_windows == 0: stats = hyper_vg.hypergraph_builder.hypergraph.get_stats() n_accu = len(hyper_vg.hypergraph_builder.hypergraph.accumulative_events) logger.info( f" [Ckpt] after {n_windows_in_session} session-windows " f"({n_windows_done} total), stats={stats}, accu_events={n_accu}" ) _save_checkpoint( hyper_vg, working_dir, progress, all_frame_captions, window_descriptions, interval_sec, timeline.participant_id, cur_window_state=_snapshot_cur_window_state(), ) try: hyper_vg.hypergraph_builder.log_timing_summary( prefix=f"(after {n_windows_in_session} windows)" ) except Exception: pass def _append_session_gap(prev_day: int, next_day: int, prev_end_abs: float, next_start_abs: float) -> None: cross_day = prev_day != next_day try: hyper_vg.hypergraph_builder.hypergraph.append_accumulative_event( AccumulativeEvent( event_type="session_gap", time_sec=next_start_abs, episode_id="", data={ "prev_end_sec": prev_end_abs, "prev_day": prev_day, "next_day": next_day, "gap_duration_sec": next_start_abs - prev_end_abs, "cross_day": cross_day, }, ) ) except Exception as e: logger.warning(f"append session_gap failed: {e}") # resume 友好: 已在 cur_window 中的帧(由 progress.cur_window_state 恢复) # 用 frame_key (DAYd-start-end) 标识, 避免重复 append cur_window_frame_keys = set() for m in cur_frame_meta: cur_window_frame_keys.add(_frame_key(m)) # ---- 4) 主循环: 逐 seg 抽帧 → 帧级 skip → append 到 window → 触发检测 ---- try: for (seg_idx, seg) in segs_all: # 4.1 抽该文件的帧 frames_rgb = _sample_frames_middle( seg.file_path, interval_sec=interval_sec, max_long_edge=max_long_edge, ) if not frames_rgb: logger.warning(f" [Sample] no frames in {os.path.basename(seg.file_path)}, skip") continue # 每帧的绝对秒范围(相对于 seg.start_sec_in_day) + 源文件锚点(供 resume 重抽) num_intervals = int(np.ceil(seg.duration_sec / interval_sec)) seg_frame_info = [] for fi in range(min(num_intervals, len(frames_rgb))): f_start = seg.start_sec_in_day + fi * interval_sec f_end = min(seg.end_sec_in_day, f_start + interval_sec) src_offset_sec = min(seg.duration_sec - 1e-3, fi * interval_sec + interval_sec / 2.0) seg_frame_info.append({ "day": seg.day, "start_sec_in_day": f_start, "end_sec_in_day": f_end, "src_file": seg.file_path, "src_offset_sec": src_offset_sec, }) # 4.1.5 整个文件全部帧已被 processed → 直接跳过 seg_frame_keys = [_frame_key(m) for m in seg_frame_info] if all(k in processed_frame_keys for k in seg_frame_keys): prev_seg_day = seg.day continue # 4.2 把帧一个一个 append 到 window, 按规则触发 flush for fi, rgb in enumerate(frames_rgb): if fi >= len(seg_frame_info): break meta = seg_frame_info[fi] fkey_str = _frame_key(meta) # 跳过已 flush 进 hypergraph 的帧 if fkey_str in processed_frame_keys: continue # 跳过已被 cur_window 恢复的帧 (resume 路径) if fkey_str in cur_window_frame_keys: continue frame_start_abs = _absolute_sec(meta["day"], meta["start_sec_in_day"]) frame_end_abs = _absolute_sec(meta["day"], meta["end_sec_in_day"]) # 触发条件检查(在 append 之前) if window_start_day is not None: window_start_abs = _absolute_sec(window_start_day, window_start_sec) window_duration = frame_end_abs - window_start_abs is_gap = ( last_frame_end_sec_absolute is not None and frame_start_abs - last_frame_end_sec_absolute >= gap_threshold_sec ) day_changed = meta["day"] != window_start_day if day_changed or is_gap or window_duration >= window_seconds: # 先 flush 当前 window _flush_window( reason=( "day_changed" if day_changed else "gap" if is_gap else "window_full" ) ) # 跨天/跨 gap 追加 session_gap 事件, 同时清空 prior(session 重开始) if day_changed or is_gap: _append_session_gap( prev_day=window_start_day if window_start_day else meta["day"], next_day=meta["day"], prev_end_abs=last_frame_end_sec_absolute or frame_start_abs, next_start_abs=frame_start_abs, ) prev_tail_captions = [] # append 帧到 window if window_start_day is None: window_start_day = meta["day"] window_start_sec = meta["start_sec_in_day"] cur_frames_b64.append(_np_to_base64_jpeg(rgb)) cur_frame_meta.append(meta) last_frame_end_sec_absolute = frame_end_abs # 4.3 帧级 progress 已由 _flush_window 维护; 这里只更新进度日志 progress["last_seg_index"] = seg_idx processed_in_session += 1 prev_seg_day = seg.day # 循环结束: 如果还有剩余帧,强制 flush if cur_frames_b64: _flush_window(reason="eof") # 最终 flush builder + 存盘 try: loop.run_until_complete(hyper_vg.hypergraph_builder.flush()) except Exception as e: logger.error(f"[final] builder.flush failed: {e}") progress["last_day_completed"] = prev_seg_day or 0 _save_checkpoint( hyper_vg, working_dir, progress, all_frame_captions, window_descriptions, interval_sec, timeline.participant_id, ) except KeyboardInterrupt: logger.warning("[Egolife] KeyboardInterrupt — saving checkpoint then exiting") try: if cur_frames_b64: _flush_window(reason="interrupt") loop.run_until_complete(hyper_vg.hypergraph_builder.flush()) except Exception: pass _save_checkpoint( hyper_vg, working_dir, progress, all_frame_captions, window_descriptions, interval_sec, timeline.participant_id, ) raise except Exception as e: logger.exception(f"[Egolife] unexpected error: {e}") try: if cur_frames_b64: _flush_window(reason="error") loop.run_until_complete(hyper_vg.hypergraph_builder.flush()) except Exception: pass _save_checkpoint( hyper_vg, working_dir, progress, all_frame_captions, window_descriptions, interval_sec, timeline.participant_id, ) raise try: hyper_vg.hypergraph_builder.log_timing_summary(prefix="(final)") except Exception: pass stats = hyper_vg.hypergraph_builder.hypergraph.get_stats() n_accu = len(hyper_vg.hypergraph_builder.hypergraph.accumulative_events) logger.info( f"[Done] hypergraph built, stats={stats}, accu_events={n_accu}, " f"this-run segs_processed={processed_in_session} windows={n_windows_in_session}" ) # ============================================================ # CLI # ============================================================ def main(): parser = argparse.ArgumentParser(description="EgoLife 建图入口(hypergraph + 积累事件)") parser.add_argument("--egolife_root", type=str, default="/mnt/tokyo-ai/gst/EgoLife/egolife", help="EgoLife 视频根目录(下面是各参与者子目录)") parser.add_argument("--participant", type=str, default="A1_JAKE", help="参与者 ID (目录名,如 A1_JAKE)") parser.add_argument("--days", type=str, default=None, help="逗号分隔要跑的 day 编号,如 '1' 或 '1,2,3'; 默认全量") parser.add_argument("--save_root", type=str, default="/mnt/tokyo-ai/gst/GST_EGOSERVE/all_results", help="输出根目录") parser.add_argument("--datasets_type", type=str, default="egolife_hyper_v2", help="输出目录后缀(参与者-{datasets_type}/{caption_model})") parser.add_argument("--caption_model", type=str, default="qwen_api", help="caption 模型: qwen_api (DashScope) / " "qwenvl_3_8b_instruct / gpt_api / gemini_api") parser.add_argument("--qwen_api_model", type=str, default="qwen-vl-max", help="DashScope 模型名(caption_model=qwen_api 时生效)") parser.add_argument("--qwen_api_key", type=str, default="YOUR_API_KEY") parser.add_argument("--openai_key", type=str, default="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", help="OpenAI key(gpt_4o_mini_complete 使用)") parser.add_argument("--cuda", type=str, default="0", help="本地 VLM 时使用的 GPU 编号") parser.add_argument("--interval_seconds", type=float, default=3.0, help="抽帧间隔秒(EgoLife 默认 3,即每 3s 一帧)") parser.add_argument("--window_seconds", type=float, default=30.0, help="跨文件累积的 window 时长(默认 30s, 10 帧/window)") parser.add_argument("--max_long_edge", type=int, default=560, help="帧长边 resize 到(默认 560)") parser.add_argument("--max_new_tokens", type=int, default=2048) parser.add_argument("--gap_threshold_sec", type=float, default=60.0, help="session_gap 判定阈值(默认 60s,相邻帧间隔超过则截窗+插 session_gap)") parser.add_argument("--no_probe_duration", action="store_true", help="扫时间线时不读实测时长(每段按 30s 假设)") parser.add_argument("--only_first_n", type=int, default=None, help="只跑前 N 段(快速 smoke)") parser.add_argument("--checkpoint_every", type=int, default=10, help="每 N 个 window 存一次盘 (hypergraph+frame_captions+progress.json)") args = parser.parse_args() os.environ["CUDA_VISIBLE_DEVICES"] = args.cuda os.environ["OPENAI_API_KEY"] = args.openai_key # 1) 扫时间线 participant_root = os.path.join(args.egolife_root, args.participant) logger.info(f"Scanning {participant_root} ...") timeline = ParticipantTimeline.scan( participant_root, gap_threshold_sec=args.gap_threshold_sec, probe_duration=not args.no_probe_duration, ) logger.info( f"Timeline: {len(timeline.segments)} segments, " f"{len(timeline.gaps)} gaps, " f"total {timeline.total_duration_sec()/3600:.1f}h" ) day_filter: Optional[List[int]] = None if args.days: day_filter = [int(d.replace("DAY", "").strip()) for d in args.days.split(",") if d.strip()] logger.info(f"Day filter: {day_filter}") if args.only_first_n: timeline.segments = timeline.segments[:args.only_first_n] # 重扫 gap (只保留仍在范围内的) timeline.gaps = [ g for g in timeline.gaps if g.next_segment_index < len(timeline.segments) ] logger.info(f"only_first_n={args.only_first_n}: trimmed to {len(timeline.segments)} segs") # 2) HyperVideoGraph 工作目录 tag = f"{args.participant}-{args.datasets_type}-{args.caption_model}" if day_filter: tag += "-DAY" + "_".join(str(d) for d in day_filter) if args.only_first_n: tag += f"-first{args.only_first_n}" working_dir = os.path.join(args.save_root, tag) os.makedirs(working_dir, exist_ok=True) logger.info(f"working_dir = {working_dir}") # 3) 构造 HyperVideoConfig (激活 EgoLife 模式) config = HyperVideoConfig( dataset_mode="egolife", caption_prompt_profile="egolife", caption_window_seconds=30.0, caption_frame_interval_sec=args.interval_seconds, egolife_accumulative_event_enabled=True, egolife_session_gap_threshold_sec=args.gap_threshold_sec, # V2 流式路径 caption_granularity="per_window", boundary_strategy="stream", # 积累事件专注短期 → episode 短 max_buffer_seconds=300.0, ) hyper_vg = HyperVideoGraph( working_dir=working_dir, llm=default_llm_config, hyper_config=config, ) # 4) 加载 caption 模型 if args.caption_model == "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 == "gpt_api": hyper_vg.load_caption_model("gpt_api") else: # 本地权重 hyper_vg.load_caption_model(args.caption_model) # 5) 跑! run_participant_construction( hyper_vg=hyper_vg, timeline=timeline, working_dir=working_dir, day_filter=day_filter, interval_sec=args.interval_seconds, window_seconds=args.window_seconds, gap_threshold_sec=args.gap_threshold_sec, max_new_tokens=args.max_new_tokens, max_long_edge=args.max_long_edge, checkpoint_every_windows=args.checkpoint_every, ) # 6) 导出 timeline 元数据供后续回放 / 审阅 try: with open(os.path.join(working_dir, "timeline.json"), "w") as f: json.dump(timeline.to_dict(), f, indent=2, ensure_ascii=False) except Exception as e: logger.warning(f"save timeline.json failed: {e}") # 7) 释放 GPU try: hyper_vg.caption_model = None hyper_vg.video_llm = None gc.collect() if torch.cuda.is_available(): torch.cuda.empty_cache() except Exception: pass logger.info("[Egolife] all done.") if __name__ == "__main__": main()