code/verify_actions.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
verify_actions.py —— 动作标签的端到端校验

这份数据的全部价值在于「动作标签与画面逐帧对得上」。前面每一步（偏移、世界→屏幕
映射、8 方向分桶）都可能悄悄错掉符号或差一格，而错了不会有任何报错 —— 只会训出
一个「按 W 之后画面往左走」的模型。

所以这里做一次闭环：
    预测方向 = 从日志速度经 M 投影到屏幕，再分成 8 桶（= 数据集里写进 prompt 的标签）
    实测方向 = 从视频相位相关直接量出来的画面位移，同样分成 8 桶
两者做混淆矩阵。对角线占优 = 标签是对的；整体偏移一格 = 分桶差一格；
对角线跑到反对角 = 符号反了。
"""
from __future__ import annotations

import argparse
import json
import os

import numpy as np

import align_flow as AF
from scenes import ACTIONS

SPEED_MIN_WORLD = 1.2       # m/s，低于此不参与（站着不动没有方向）
SPEED_MIN_PIX = 1.5         # px/基线，光流太小时方向不可靠


def to_bucket(sx, sy):
    """屏幕速度 -> 1..8（与 scenes.ACTIONS 的索引一致）。sy 向下为正。"""
    ang = np.degrees(np.arctan2(-sy, sx))
    return 1 + (np.round((ang - 90.0) / 45.0).astype(np.int64) % 8)


def main():
    ap = argparse.ArgumentParser(description="动作标签闭环校验")
    ap.add_argument("--raw", default="/data/zhiyangdeng/EYBXROAM")
    ap.add_argument("--logs", default="/data/zhiyangdeng/data_eybx/logs")
    ap.add_argument("--sessions", nargs="*", default=None)
    ap.add_argument("--n_win", type=int, default=30)
    ap.add_argument("--dur", type=float, default=25.0)
    ap.add_argument("--seed", type=int, default=31)
    args = ap.parse_args()

    sessions = args.sessions or ["20260821_190601_787", "20260823_201942_753"]
    CM = np.zeros((9, 9), np.int64)
    for sid in sessions:
        d = os.path.join(args.logs, sid)
        off_j = json.load(open(os.path.join(d, "offsets.json"), encoding="utf-8"))
        M = np.array(off_j["M_px1280"])
        Mraw = M / ((1280.0 / AF.PW) * 30.0 / AF.STRIDE)
        los = np.array([s["vt_lo"] for s in off_j["segments"]])
        offs = np.array([s["offset"] for s in off_j["segments"]])

        st = np.load(os.path.join(d, "state.npz")); o = np.argsort(st["vt"])
        vt, x, z = AF.dedupe_time(st["vt"][o], st["x"][o].astype(np.float64),
                                  st["z"][o].astype(np.float64))
        yv = np.interp(vt, st["vt"][o], st["y"][o].astype(np.float64))
        wx, wy, wz = np.gradient(x, vt), np.gradient(yv, vt), np.gradient(z, vt)
        lum = np.load(os.path.join(d, "lum.npz")); mean = lum["mean"]; fps = float(lum["fps"])
        events = json.load(open(os.path.join(d, "events.json"), encoding="utf-8"))
        vid = os.path.join(args.raw, sid, "video.mp4")
        rng = np.random.default_rng(args.seed)
        wins = AF.pick_windows(mean, fps, events, args.n_win, args.dur, 900, vt.max() - 900, rng)
        n_used = 0
        for t0 in wins:
            fr = AF.decode_window(vid, t0, args.dur)
            if fr is None:
                continue
            vx, vy_, _ = AF.flow_series(fr)
            g_vid = t0 + (np.arange(vx.size) + AF.STRIDE / 2) / fps
            i = np.clip(np.searchsorted(los, g_vid, side="right") - 1, 0, offs.size - 1)
            g_log = g_vid - offs[i]                      # 视频时间 -> 日志时间
            lwx = np.interp(g_log, vt, wx); lwy = np.interp(g_log, vt, wy)
            lwz = np.interp(g_log, vt, wz)
            spd = np.hypot(lwx, lwz)
            px = Mraw[0, 0] * lwx + Mraw[1, 0] * lwy + Mraw[2, 0] * lwz
            py = Mraw[0, 1] * lwx + Mraw[1, 1] * lwy + Mraw[2, 1] * lwz
            m = (spd > SPEED_MIN_WORLD) & (spd < AF.SPEED_CAP) & \
                (np.hypot(vx, vy_) > SPEED_MIN_PIX)
            if m.sum() < 20:
                continue
            pred = to_bucket(px[m], py[m])
            meas = to_bucket(vx[m], vy_[m])
            np.add.at(CM, (pred, meas), 1)
            n_used += 1
        print(f"   {sid}: 用了 {n_used}/{len(wins)} 个窗口", flush=True)

    import json as _json
    _json.dump(dict(matrix=CM.tolist(), actions=ACTIONS,
                    n_win=args.n_win, dur=args.dur, sessions=sessions),
               open("/data/zhiyangdeng/eybx/confusion.json", "w"), ensure_ascii=False)
    tot = CM.sum()
    diag = np.trace(CM)
    # ±1 桶（相邻 45°）也算基本正确 —— 分桶边界附近的抖动不是错误
    near = sum(CM[i, ((i - 1 - 1) % 8) + 1] + CM[i, i] + CM[i, ((i - 1 + 1) % 8) + 1]
               for i in range(1, 9))
    print(f"\n有效样本 {tot:,}")
    print(f"  完全一致        {diag:,}  = {100*diag/max(tot,1):.1f}%")
    print(f"  ±1 桶(±45°)内   {near:,}  = {100*near/max(tot,1):.1f}%")
    print("\n混淆矩阵（行=日志预测，列=视频实测）")
    print("        " + "".join(f"{ACTIONS[j][7:][:6]:>7}" for j in range(1, 9)))
    for i in range(1, 9):
        row = CM[i, 1:]
        s = row.sum()
        print(f"{ACTIONS[i][7:]:>8}" + "".join(f"{100*v/max(s,1):6.0f}%" for v in row))
    # 整体是否系统性偏一格
    shifts = [sum(CM[i, ((i - 1 + k) % 8) + 1] for i in range(1, 9)) for k in range(8)]
    best = int(np.argmax(shifts))
    print(f"\n最佳整体旋转 = {best} 格 (0 = 无需旋转，符号与分桶都对)")
    if best != 0:
        print(f"  ⚠ 有系统性偏移 {best*45}°，需要检查 M 的符号或分桶公式")


if __name__ == "__main__":
    main()