"""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()