File size: 44,725 Bytes
a46c532 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 | """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": "<caption>", ...},
"description": "<window-level summary>",
}
"""
# 时间戳的转换
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()
|