app.py

import os
# 抑制底层库的冗余日志（TensorFlow Lite / MediaPipe / absl / grpc 等）
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
os.environ['GLOG_minloglevel'] = '2'
os.environ['GRPC_VERBOSITY'] = 'ERROR'
os.environ['ABSL_LOGGING_VERBOSITY'] = '3'
# 禁用 gradio 的遥测与版本检查，避免启动时出现 "IMPORTANT: You are using gradio version..." 的升级提示
os.environ['GRADIO_ANALYTICS_ENABLED'] = 'False'

# 屏蔽 Python 警告（mmcv v2.0 升级提示等）
import warnings
warnings.filterwarnings('ignore')

# 降低 mmcv / mmdet / mmpose 的日志等级，避免打印 "load checkpoint from local path:" 等信息
import logging
for _lib in ('mmcv', 'mmdet', 'mmpose', 'mmcv.runner', 'mmcv.runner.checkpoint'):
    logging.getLogger(_lib).setLevel(logging.ERROR)

# 兜底：gradio 的版本检查使用 print() 直接输出，不走 warnings 系统，
# 因此在 import gradio 期间额外重定向 stdout / stderr，彻底屏蔽残余提示。
import io, contextlib
import tempfile
with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
    import gradio as gr
import torch
import pickle
import numpy as np
import sys
import cv2
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import matplotlib.font_manager as fm
from mpl_toolkits.mplot3d import Axes3D

# 项目根目录 = 当前脚本所在目录，所有资源路径均基于此，保证可移植性
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, BASE_DIR)

# 临时输出目录：骨骼动画 / 骨骼数据的输出文件统一写入系统临时目录，
# 不再污染项目文件夹。Web 界面依然可以正常下载这些文件。
TEMP_DIR = tempfile.gettempdir()

# 配置中文字体，解决骨骼动画标题中文乱码问题
_chinese_font_candidates = [
    'WenQuanYi Micro Hei', 'WenQuanYi Zen Hei',
    'Noto Sans CJK SC', 'Noto Sans CJK TC', 'Noto Sans CJK JP',
    'Droid Sans Fallback', 'AR PL UMing CN', 'AR PL UKai CN',
    'SimHei', 'Microsoft YaHei', 'PingFang SC', 'Heiti SC'
]
_available_fonts = {f.name for f in fm.fontManager.ttflist}
_chinese_font_found = None
for _font in _chinese_font_candidates:
    if _font in _available_fonts:
        _chinese_font_found = _font
        break
if _chinese_font_found:
    plt.rcParams['font.sans-serif'] = [_chinese_font_found] + plt.rcParams.get('font.sans-serif', [])
    print(f"[字体] 已加载中文字体: {_chinese_font_found}")
else:
    print("[字体] 警告: 未找到任何中文字体，动画标题中文将显示为方框")
    print("[字体] 请在 WSL 中执行: sudo apt install fonts-wqy-microhei -y")
    print("[字体] 安装后删除 matplotlib 字体缓存: rm -rf ~/.cache/matplotlib")
plt.rcParams['axes.unicode_minus'] = False

NTU60_LABELS = [
    "drink water","eat meal","brush teeth","brush hair","drop",
    "pick up","throw","sit down","stand up","clapping",
    "reading","writing","tear up paper","put on jacket","take off jacket",
    "put on shoe","take off shoe","put on glasses","take off glasses","put on hat",
    "take off hat","phone call","play phone","type on keyboard","point to something",
    "taking selfie","check time","rub two hands","bow","shake head",
    "wipe face","salute","put palms together","cross hands in front","sneeze/cough",
    "staggering","falling","touch head","touch chest","touch back",
    "touch neck","nausea/vomiting","fan self","punch/slap","kicking",
    "pushing","pat on back","point finger","hugging","giving object",
    "touch pocket","shaking hands","walking towards","walking apart","put on bag",
    "take off bag","stick post-it","counting money","cutting nails","cutting paper",
]

NTU60_LABELS_CN = [
    "喝水","吃饭","刷牙","梳头","掉落物品",
    "捡起","投掷","坐下","站起","鼓掌",
    "阅读","书写","撕纸","穿上外套","脱掉外套",
    "穿鞋","脱鞋","戴眼镜","摘眼镜","戴帽子",
    "摘帽子","打电话","玩手机","打字","指向某物",
    "自拍","看时间","搓手","鞠躬","摇头",
    "擦脸","敬礼","双手合十","双手交叉胸前","打喷嚏/咳嗽",
    "蹒跚","摔倒","摸头","摸胸口","摸背",
    "摸脖子","恶心/呕吐","扇风","拳打/掌掴","踢",
    "推","拍背","指","拥抱","递物品",
    "摸口袋","握手","走近","走开","背上包",
    "取下包","贴便签","数钱","剪指甲","剪纸",
]

CONNECTIONS = [
    (0,1),(1,20),(2,20),(3,2),(4,20),(5,4),(6,5),(7,6),
    (8,20),(9,8),(10,9),(11,10),(12,0),(13,12),(14,13),
    (15,14),(16,0),(17,16),(18,17),(19,18),(21,7),(22,7),
    (23,11),(24,11)
]

# COCO 17 关节骨骼连接（用于 mmpose 方案的 2D 可视化）
COCO_CONNECTIONS = [
    (0,1),(0,2),(1,3),(2,4),       # 头部
    (5,7),(7,9),(6,8),(8,10),       # 手臂
    (5,6),(5,11),(6,12),(11,12),    # 躯干
    (11,13),(13,15),(12,14),(14,16) # 腿部
]

def extract_skeleton_from_video(video_path):
    import mediapipe as mp
    mp_pose = mp.solutions.pose
    pose = mp_pose.Pose(
        static_image_mode=False,
        model_complexity=2,
        smooth_landmarks=True,
        min_detection_confidence=0.5,
        min_tracking_confidence=0.5
    )
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    keypoints_list = []
    frames_list = []
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        frames_list.append(frame)
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = pose.process(rgb_frame)
        if results.pose_world_landmarks:
            landmarks = results.pose_world_landmarks.landmark
            kps = np.array([[lm.x, lm.y, lm.z] for lm in landmarks])
            keypoints_list.append(kps)
        else:
            if keypoints_list:
                keypoints_list.append(keypoints_list[-1])
            else:
                keypoints_list.append(np.zeros((33, 3)))
    cap.release()
    pose.close()

    T = len(keypoints_list)
    ntu_keypoints = np.zeros((T, 25, 3))
    for t, kps in enumerate(keypoints_list):
        shoulder_center = (kps[11] + kps[12]) / 2
        # 颈部和头部：水平位置(X,Z)对齐肩膀中心，只取鼻子的高度(Y)，避免前倾
        neck_y = (shoulder_center[1] + kps[0][1]) / 2     # 颈部高度：肩膀与鼻子的中间
        head_y = kps[0][1]                                 # 头部高度：鼻子高度
        ntu_keypoints[t, 0] = (kps[23] + kps[24]) / 2                  # 0: hip center
        ntu_keypoints[t, 1] = (kps[11] + kps[12] + kps[23] + kps[24]) / 4  # 1: spine mid
        ntu_keypoints[t, 2] = [shoulder_center[0], neck_y, shoulder_center[2]]  # 2: neck (垂直于肩膀上方)
        ntu_keypoints[t, 3] = [shoulder_center[0], head_y, shoulder_center[2]]  # 3: head (垂直于颈部上方)
        ntu_keypoints[t, 4] = kps[11]                                   # 4: left shoulder
        ntu_keypoints[t, 5] = kps[13]                                   # 5: left elbow
        ntu_keypoints[t, 6] = kps[15]                                   # 6: left wrist
        ntu_keypoints[t, 7] = kps[17]                                   # 7: left hand (小指)
        ntu_keypoints[t, 8] = kps[12]                                   # 8: right shoulder
        ntu_keypoints[t, 9] = kps[14]                                   # 9: right elbow
        ntu_keypoints[t, 10] = kps[16]                                  # 10: right wrist
        ntu_keypoints[t, 11] = kps[18]                                  # 11: right hand (小指)
        ntu_keypoints[t, 12] = kps[23]                                  # 12: left hip
        ntu_keypoints[t, 13] = kps[25]                                  # 13: left knee
        ntu_keypoints[t, 14] = kps[27]                                  # 14: left ankle
        ntu_keypoints[t, 15] = kps[31]                                  # 15: left foot
        ntu_keypoints[t, 16] = kps[24]                                  # 16: right hip
        ntu_keypoints[t, 17] = kps[26]                                  # 17: right knee
        ntu_keypoints[t, 18] = kps[28]                                  # 18: right ankle
        ntu_keypoints[t, 19] = kps[32]                                  # 19: right foot
        ntu_keypoints[t, 20] = shoulder_center                          # 20: shoulder center
        ntu_keypoints[t, 21] = kps[19]                                  # 21: left hand tip (食指)
        ntu_keypoints[t, 22] = kps[21]                                  # 22: left thumb
        ntu_keypoints[t, 23] = kps[20]                                  # 23: right hand tip (食指)
        ntu_keypoints[t, 24] = kps[22]                                  # 24: right thumb

    return ntu_keypoints, frames_list, fps



def extract_skeleton_mmpose(video_path):
    """使用 mmdetection + mmpose 提取 COCO 17 关节 2D 骨骼（支持多人）"""
    # ===== 懒加载：第一次调用时初始化模型，后续调用直接复用 =====
    global _det_model, _pose_model
    if '_det_model' not in globals() or _det_model is None:
        from mmdet.apis import init_detector
        from mmpose.apis import init_pose_model

        det_config = os.path.join(BASE_DIR, 'resources', 'faster_rcnn_config.py')
        det_ckpt = os.path.join(BASE_DIR, 'resources', 'checkpoints', 'faster_rcnn_person.pth')
        pose_config = os.path.join(BASE_DIR, 'resources', 'hrnet_config.py')
        pose_ckpt = os.path.join(BASE_DIR, 'resources', 'checkpoints', 'hrnet_w32_pose.pth')

        device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
        _det_model = init_detector(det_config, det_ckpt, device)
        _pose_model = init_pose_model(pose_config, pose_ckpt, device)

    from mmdet.apis import inference_detector
    from mmpose.apis import inference_top_down_pose_model
    from scipy.optimize import linear_sum_assignment
    import mmcv

    det_model = _det_model
    pose_model = _pose_model

    # 读取视频帧
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    frames = []
    while cap.isOpened():
        ret, frame = cap.read()
        if not ret:
            break
        frames.append(frame)
    cap.release()

    h, w = frames[0].shape[:2]
    T = len(frames)

    # 逐帧检测 + 姿态估计
    pose_results_all = []
    for frame in frames:
        det_results = inference_detector(det_model, frame)
        bboxes = det_results[0]
        bboxes = bboxes[bboxes[:, 4] >= 0.5]
        person_results = [dict(bbox=b) for b in bboxes]
        pose_results, _ = inference_top_down_pose_model(
            pose_model, frame, person_results, bbox_thr=0.5, format='xyxy'
        )
        pose_results_all.append(pose_results)

    # 多人追踪（来自 PYSKL 官方 demo_skeleton.py）
    def dist_ske(ske1, ske2):
        dist = np.linalg.norm(ske1[:, :2] - ske2[:, :2], axis=1) * 2
        diff = np.abs(ske1[:, 2] - ske2[:, 2])
        return np.sum(np.maximum(dist, diff))

    max_tracks = 2
    tracks, num_tracks = [], 0
    for idx, poses in enumerate(pose_results_all):
        if len(poses) == 0:
            continue
        cur_kps = [p['keypoints'] for p in poses]
        track_proposals = [t for t in tracks if t['data'][-1][0] > idx - 30]
        n, m = len(track_proposals), len(cur_kps)
        scores = np.zeros((n, m))
        for i in range(n):
            for j in range(m):
                scores[i][j] = dist_ske(track_proposals[i]['data'][-1][1], cur_kps[j])
        if n > 0 and m > 0:
            row, col = linear_sum_assignment(scores)
            for r, c in zip(row, col):
                track_proposals[r]['data'].append((idx, cur_kps[c]))
            for j in range(m):
                if j not in col:
                    num_tracks += 1
                    tracks.append(dict(track_id=num_tracks, data=[(idx, cur_kps[j])]))
        else:
            for j in range(m):
                num_tracks += 1
                tracks.append(dict(track_id=num_tracks, data=[(idx, cur_kps[j])]))

    tracks.sort(key=lambda x: -len(x['data']))
    keypoint = np.zeros((max_tracks, T, 17, 2), dtype=np.float32)
    keypoint_score = np.zeros((max_tracks, T, 17), dtype=np.float32)
    for i, track in enumerate(tracks[:max_tracks]):
        for item in track['data']:
            idx, kps = item
            keypoint[i, idx] = kps[:, :2]
            keypoint_score[i, idx] = kps[:, 2]

    return keypoint, keypoint_score, frames, fps, h, w


def load_model():
    from mmcv import Config
    from pyskl.models import build_model
    config = Config.fromfile(os.path.join(BASE_DIR, 'configs', 'stgcn', 'stgcn_pyskl_ntu60_xsub_3dkp', 'j.py'))
    model = build_model(config.model)
    checkpoint = torch.load(
        os.path.join(BASE_DIR, 'models', 'stgcn_3d', 'model.pth'),
        map_location='cpu'
    )
    model.load_state_dict(checkpoint['state_dict'], strict=False)
    model.eval()
    model.cfg = config
    return model

def load_model_hrnet():
    """加载 PYSKL 官方预训练的 2D ST-GCN 模型（NTU60 X-Sub, HRNet COCO 17 关节, Top-1: 89.0%）"""
    from mmcv import Config
    from pyskl.models import build_model
    config = Config.fromfile(os.path.join(BASE_DIR, 'configs', 'stgcn', 'stgcn_pyskl_ntu60_xsub_hrnet', 'j.py'))
    model = build_model(config.model)
    checkpoint = torch.load(os.path.join(BASE_DIR, 'models', 'stgcn_2d_hrnet', 'model.pth'), map_location='cpu')
    # 兼容不同的权重文件格式
    if 'state_dict' in checkpoint:
        state_dict = checkpoint['state_dict']
    elif 'model_state_dict' in checkpoint:
        state_dict = checkpoint['model_state_dict']
    else:
        state_dict = checkpoint
    model.load_state_dict(state_dict, strict=False)
    model.eval()
    model.cfg = config
    return model

print("[系统] 正在加载模型...")
# 加载模型时屏蔽底层库打印的 "load checkpoint from local path:" 等信息
with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
    model = load_model()
    model_hrnet = load_model_hrnet()
print("[系统] 模型加载完成")


def make_status_html(text):
    return f"""<div style="
        background:rgba(0,210,255,0.08); border:1px solid rgba(0,210,255,0.2);
        border-radius:10px; padding:16px; min-height:80px; width:100%;
        box-sizing:border-box; display:flex; align-items:center; justify-content:center;">
        <p style="color:#000000; text-align:center; margin:0; line-height:1.8; width:100%;">{text}</p>
    </div>"""


def predict_from_pkl(skeleton_file):
    if skeleton_file is None:
        return make_status_html("请先上传骨骼数据文件 / Please upload a skeleton data file first")
    try:
        from pyskl.apis import inference_recognizer

        with open(skeleton_file.name, 'rb') as f:
            data = pickle.load(f)

        # 构造标准 annotation dict
        if isinstance(data, dict):
            keypoint = data.get('keypoint', None)
            if keypoint is None:
                return make_status_html("pkl文件中未找到keypoint字段 / No keypoint field found in pkl file")
            keypoint = np.array(keypoint)
            total_frames = data.get('total_frames', keypoint.shape[-3] if keypoint.ndim >= 3 else 0)
        elif isinstance(data, np.ndarray):
            keypoint = data
            total_frames = keypoint.shape[-3] if keypoint.ndim >= 3 else 0
        else:
            return make_status_html(f"不支持的数据格式 / Unsupported data format")

        # 确保 keypoint 格式为 (M, T, V, C)
        if keypoint.ndim == 3:
            # (T, V, C) → (1, T, V, C)
            keypoint = keypoint[np.newaxis]
            total_frames = keypoint.shape[1]
        elif keypoint.ndim == 4:
            # 已经是 (M, T, V, C)
            total_frames = keypoint.shape[1]

        anno = dict(
            keypoint=keypoint.copy(),
            total_frames=total_frames,
            frame_dir='custom_pkl',
            label=0,
            start_index=0,
            modality='Pose',
            test_mode=True
        )
        results = inference_recognizer(model, anno)  # top5: [(class_id, score), ...]

        lines = "✅ 识别完成 / Recognition Complete<br><br>"
        for i, (idx, score) in enumerate(results):
            label_en = NTU60_LABELS[idx] if idx < len(NTU60_LABELS) else f"Action {idx}"
            label_cn = NTU60_LABELS_CN[idx] if idx < len(NTU60_LABELS_CN) else f"动作 {idx}"
            bar = "█" * int(score * 20)
            lines += f"Top{i+1}：{label_cn} / {label_en} &nbsp; {score:.1%} {bar}<br>"
        return make_status_html(lines)
    except Exception as e:
        return make_status_html(f"处理出错 / Error: {str(e)}")


def process_video(video_path):
    if video_path is None:
        return None, make_status_html("请先上传视频文件 / Please upload a video first")
    try:
        from pyskl.apis import inference_recognizer

        keypoints, frames, fps = extract_skeleton_from_video(video_path)
        T = keypoints.shape[0]

        # 构造标准 annotation dict，走完整 pipeline:
        # PreNormalize3D → GenSkeFeat → UniformSample(100帧×10clips) → FormatGCNInput(2人)
        anno = dict(
            keypoint=keypoints[np.newaxis].copy(),  # (1, T, 25, 3) = (M, T, V, C)
            total_frames=T,
            frame_dir='custom_video',
            label=0,
            start_index=0,
            modality='Pose',
            test_mode=True
        )
        results = inference_recognizer(model, anno)  # 返回 top5: [(class_id, score), ...]
        top1_idx, top1_prob = results[0]
        top1_label_en = NTU60_LABELS[top1_idx] if top1_idx < len(NTU60_LABELS) else f"Action {top1_idx}"
        top1_label_cn = NTU60_LABELS_CN[top1_idx] if top1_idx < len(NTU60_LABELS_CN) else f"动作 {top1_idx}"

        render_T = min(T, 100)
        all_joints = keypoints[:render_T]
        cx = (all_joints[:,:,0].min() + all_joints[:,:,0].max()) / 2
        cy = (all_joints[:,:,2].min() + all_joints[:,:,2].max()) / 2
        cz = (-all_joints[:,:,1].max() + -all_joints[:,:,1].min()) / 2
        radius = max(
            all_joints[:,:,0].max() - all_joints[:,:,0].min(),
            all_joints[:,:,2].max() - all_joints[:,:,2].min(),
            all_joints[:,:,1].max() - all_joints[:,:,1].min()
        ) / 2 + 0.2

        fig = plt.figure(figsize=(16, 9), facecolor='black')
        ax = fig.add_subplot(111, projection='3d')

        def update(frame):
            ax.cla()
            ax.set_facecolor('black')
            joints = keypoints[frame]
            ax.scatter(joints[:,0], joints[:,2], -joints[:,1], c='yellow', s=60)
            for i, j in CONNECTIONS:
                ax.plot([joints[i,0], joints[j,0]],
                        [joints[i,2], joints[j,2]],
                        [-joints[i,1], -joints[j,1]], 'c-', linewidth=2)
            ax.set_title(f'{top1_label_cn} / {top1_label_en} ({top1_prob:.1%}) | Frame: {frame+1}/{render_T}',
                        color='white', fontsize=10)
            ax.set_xlim([cx-radius, cx+radius])
            ax.set_ylim([cy-radius, cy+radius])
            ax.set_zlim([cz-radius, cz+radius])
            ax.view_init(elev=10, azim=-90)
            ax.tick_params(colors='white')
            for pane in [ax.xaxis.pane, ax.yaxis.pane, ax.zaxis.pane]:
                pane.fill = False

        ani = animation.FuncAnimation(fig, update, frames=render_T, interval=100)
        output_path = os.path.join(TEMP_DIR, 'output_skeleton.mp4')
        ani.save(output_path, writer='ffmpeg', fps=10, savefig_kwargs={'facecolor': 'black'})
        plt.close()

        lines = f"✅ 处理完成 / Processing Complete！共 {T} 帧<br><br>"
        for i, (idx, score) in enumerate(results):
            label_en = NTU60_LABELS[idx] if idx < len(NTU60_LABELS) else f"Action {idx}"
            label_cn = NTU60_LABELS_CN[idx] if idx < len(NTU60_LABELS_CN) else f"动作 {idx}"
            bar = "█" * int(score * 20)
            lines += f"Top{i+1}：{label_cn} / {label_en} &nbsp; {score:.1%} {bar}<br>"
        return output_path, make_status_html(lines)
    except Exception as e:
        import traceback
        return None, make_status_html(f"处理失败 / Failed: {str(e)}")


def process_video_mmpose(video_path):
    """使用 mmpose + HRNet 方案进行视频分析（2D 骨骼, COCO 17 关节）"""
    if video_path is None:
        return None, make_status_html("请先上传视频文件 / Please upload a video first")
    try:
        from pyskl.apis import inference_recognizer

        keypoint, keypoint_score, frames, fps, h, w = extract_skeleton_mmpose(video_path)
        T = len(frames)
        M = keypoint.shape[0]  # 人数（最多 2）

        # 构造 annotation dict（2D 格式，含 keypoint_score）
        anno = dict(
            keypoint=keypoint.copy(),
            keypoint_score=keypoint_score.copy(),
            total_frames=T,
            img_shape=(h, w),
            original_shape=(h, w),
            frame_dir='custom_video',
            label=0,
            start_index=0,
            modality='Pose',
            test_mode=True
        )
        results = inference_recognizer(model_hrnet, anno)
        top1_idx, top1_prob = results[0]
        top1_label_en = NTU60_LABELS[top1_idx] if top1_idx < len(NTU60_LABELS) else f"Action {top1_idx}"
        top1_label_cn = NTU60_LABELS_CN[top1_idx] if top1_idx < len(NTU60_LABELS_CN) else f"动作 {top1_idx}"

        # 生成 2D 骨骼可视化动画
        render_T = min(T, 100)
        fig, ax_2d = plt.subplots(1, 1, figsize=(16, 9), facecolor='black')
        colors_person = ['#00d2ff', '#ff6b6b']  # 两个人用不同颜色

        def update(frame_idx):
            ax_2d.cla()
            ax_2d.set_facecolor('black')
            ax_2d.set_xlim([0, w])
            ax_2d.set_ylim([h, 0])  # y轴翻转，图像坐标系
            ax_2d.set_aspect('equal')
            ax_2d.axis('off')

            # 显示原始视频帧作为背景
            ax_2d.imshow(cv2.cvtColor(frames[frame_idx], cv2.COLOR_BGR2RGB), extent=[0, w, h, 0])

            for person_idx in range(M):
                kps = keypoint[person_idx, frame_idx]  # (17, 2)
                scores = keypoint_score[person_idx, frame_idx]  # (17,)
                if np.sum(scores) < 1.0:
                    continue
                color = colors_person[person_idx % 2]
                # 绘制关节点
                valid = scores > 0.3
                ax_2d.scatter(kps[valid, 0], kps[valid, 1], c=color, s=40, zorder=5)
                # 绘制骨骼连接
                for i, j in COCO_CONNECTIONS:
                    if scores[i] > 0.3 and scores[j] > 0.3:
                        ax_2d.plot([kps[i, 0], kps[j, 0]], [kps[i, 1], kps[j, 1]],
                                   color=color, linewidth=2, zorder=4)
            ax_2d.set_title(
                f'{top1_label_cn} / {top1_label_en} ({top1_prob:.1%}) | Frame: {frame_idx+1}/{render_T}',
                color='white', fontsize=12, pad=10)

        ani = animation.FuncAnimation(fig, update, frames=render_T, interval=100)
        output_path = os.path.join(TEMP_DIR, 'output_skeleton_mmpose.mp4')
        ani.save(output_path, writer='ffmpeg', fps=10, savefig_kwargs={'facecolor': 'black'})
        plt.close()

        lines = f"✅ 处理完成 / Processing Complete！共 {T} 帧<br>"
        lines += f"📌 提取方式 / Extraction: mmpose + HRNet（COCO 17 关节 2D）<br>"
        lines += f"📌 识别模型 / Model: ST-GCN（HRNet 2D, Top-1: 89.0%）<br><br>"
        for i, (idx, score) in enumerate(results):
            label_en = NTU60_LABELS[idx] if idx < len(NTU60_LABELS) else f"Action {idx}"
            label_cn = NTU60_LABELS_CN[idx] if idx < len(NTU60_LABELS_CN) else f"动作 {idx}"
            bar = "█" * int(score * 20)
            lines += f"Top{i+1}：{label_cn} / {label_en} &nbsp; {score:.1%} {bar}<br>"
        return output_path, make_status_html(lines)
    except Exception as e:
        import traceback
        traceback.print_exc()
        return None, make_status_html(f"处理失败 / Failed: {str(e)}")


def video_to_pkl(video_path):
    """MediaPipe 方案：视频转 pkl（NTU 25 关节 3D）"""
    if video_path is None:
        return None, make_status_html("请先上传视频文件 / Please upload a video first")
    # 兼容 gr.File 返回的文件包装对象（带 .name 属性）与 gr.Video 返回的路径字符串
    if hasattr(video_path, 'name'):
        video_path = video_path.name
    try:
        keypoints, frames, fps = extract_skeleton_from_video(video_path)
        T = keypoints.shape[0]
        pkl_data = {
            'keypoint': keypoints[np.newaxis],  # (1, T, 25, 3)
            'total_frames': T,
            'label': -1,
            'frame_dir': 'custom_video'
        }
        output_path = os.path.join(TEMP_DIR, 'output_skeleton_3d.pkl')
        with open(output_path, 'wb') as f:
            pickle.dump(pkl_data, f)
        return output_path, make_status_html(f"✅ 转换完成 / Conversion Complete<br>骨骼格式 / Format：NTU 25 关节 3D<br>总帧数 / Total Frames：{T}<br>关节点数 / Joints：25 × 3D<br>文件已保存，可下载后用于 MediaPipe 标准识别<br>File saved. Download for MediaPipe standard recognition.")
    except Exception as e:
        return None, make_status_html(f"转换失败 / Conversion Failed: {str(e)}")


def video_to_pkl_mmpose(video_path):
    """mmpose 方案：视频转 pkl（COCO 17 关节 2D）"""
    if video_path is None:
        return None, make_status_html("请先上传视频文件 / Please upload a video first")
    # 兼容 gr.File 返回的文件包装对象与 gr.Video 返回的路径字符串
    if hasattr(video_path, 'name'):
        video_path = video_path.name
    try:
        keypoint, keypoint_score, frames, fps, h, w = extract_skeleton_mmpose(video_path)
        T = len(frames)
        pkl_data = {
            'keypoint': keypoint,               # (M, T, 17, 2)
            'keypoint_score': keypoint_score,    # (M, T, 17)
            'total_frames': T,
            'img_shape': (h, w),
            'label': -1,
            'frame_dir': 'custom_video'
        }
        output_path = os.path.join(TEMP_DIR, 'output_skeleton_2d.pkl')
        with open(output_path, 'wb') as f:
            pickle.dump(pkl_data, f)
        M = keypoint.shape[0]
        return output_path, make_status_html(f"✅ 转换完成 / Conversion Complete<br>骨骼格式 / Format：COCO 17 关节 2D<br>总帧数 / Total Frames：{T}<br>检测人数 / Persons：{M}<br>关节点数 / Joints：17 × 2D + score<br>文件已保存，可下载后用于 mmpose 标准识别<br>File saved. Download for mmpose standard recognition.")
    except Exception as e:
        import traceback
        traceback.print_exc()
        return None, make_status_html(f"转换失败 / Conversion Failed: {str(e)}")


def predict_from_pkl_mmpose(skeleton_file):
    """mmpose 方案：从 2D pkl 文件进行标准识别"""
    if skeleton_file is None:
        return make_status_html("请先上传骨骼数据文件 / Please upload a skeleton data file first")
    try:
        from pyskl.apis import inference_recognizer

        with open(skeleton_file.name, 'rb') as f:
            data = pickle.load(f)

        if not isinstance(data, dict):
            return make_status_html("不支持的数据格式 / Unsupported data format")

        keypoint = data.get('keypoint', None)
        if keypoint is None:
            return make_status_html("pkl文件中未找到keypoint字段 / No keypoint field found in pkl file")
        keypoint = np.array(keypoint)
        keypoint_score = data.get('keypoint_score', None)
        if keypoint_score is not None:
            keypoint_score = np.array(keypoint_score)

        total_frames = data.get('total_frames', keypoint.shape[1] if keypoint.ndim >= 2 else 0)
        img_shape = data.get('img_shape', (1080, 1920))

        anno = dict(
            keypoint=keypoint.copy(),
            total_frames=total_frames,
            img_shape=img_shape,
            original_shape=img_shape,
            frame_dir='custom_pkl',
            label=0,
            start_index=0,
            modality='Pose',
            test_mode=True
        )
        if keypoint_score is not None:
            anno['keypoint_score'] = keypoint_score.copy()

        results = inference_recognizer(model_hrnet, anno)

        lines = "✅ 识别完成 / Recognition Complete<br>"
        lines += "📌 模型 / Model：ST-GCN（HRNet 2D, COCO 17 关节）<br><br>"
        for i, (idx, score) in enumerate(results):
            label_en = NTU60_LABELS[idx] if idx < len(NTU60_LABELS) else f"Action {idx}"
            label_cn = NTU60_LABELS_CN[idx] if idx < len(NTU60_LABELS_CN) else f"动作 {idx}"
            bar = "█" * int(score * 20)
            lines += f"Top{i+1}：{label_cn} / {label_en} &nbsp; {score:.1%} {bar}<br>"
        return make_status_html(lines)
    except Exception as e:
        import traceback
        traceback.print_exc()
        return make_status_html(f"处理出错 / Error: {str(e)}")


with gr.Blocks(title="骨骼动作识别系统") as app:

    gr.HTML("""
    <style>
    body { background: linear-gradient(135deg, #0f0c29, #302b63, #24243e) !important; }
    .gradio-container { background: transparent !important; max-width: 1000px !important; margin: 0 auto !important; }
    .gr-button-primary {
        background: linear-gradient(90deg, #00d2ff, #7b2ff7) !important;
        border: none !important; border-radius: 12px !important;
        font-size: 1.05em !important; font-weight: 600 !important; color: white !important;
    }
    .video-label {
        color: #ccc; font-size: 0.95em; margin-bottom: 8px;
        min-height: 28px; display: flex; align-items: center;
    }
    /* 强制视频框等宽等高 */
    .video-row > .gr-column { flex: 1 1 0 !important; min-width: 0 !important; }
    .video-row video, .video-row .video-container {
        width: 100% !important; aspect-ratio: 16/9 !important; object-fit: contain !important;
    }
    .center-row {
        display: flex !important; justify-content: center !important;
        align-items: center !important; margin: 16px 0 !important;
    }
    .action-container {
        display: flex !important; flex-direction: column !important;
        align-items: center !important; gap: 15px !important;
        width: auto !important; margin: 0 auto !important;
    }
    .action-container .gr-button { width: 150px !important; min-width: 120px !important; }
    .action-container .gr-html { width: 300px !important; min-width: 250px !important; }
    /* 骨骼数据识别 Tab：文件上传框 + 识别按钮 + 识别结果，全部居中单栏、三者等宽 */
    /* 骨骼数据提取 Tab：File 控件固定为薄卡片高度，和提取完成后状态一致 */
    .conv-file {
        height: 100px !important;
        min-height: 100px !important;
        max-height: 100px !important;
        overflow: hidden !important;
    }
    /* 左框（用户上传的视频文件）不需要下载按钮 */
    .conv-input a[download],
    .conv-input a[href$=".mp4"],
    .conv-input a[href$=".mov"],
    .conv-input a[href$=".avi"],
    .conv-input a[href$=".mkv"],
    .conv-input .download-link,
    .conv-input .file-preview-handler {
        display: none !important;
    }
    .pkl-panel {
        display: flex !important;
        flex-direction: column !important;
        align-items: center !important;
        gap: 15px !important;
        width: auto !important;
        margin: 0 auto !important;
    }
    .pkl-item {
        width: 320px !important;
        min-width: 320px !important;
        max-width: 320px !important;
        flex-grow: 0 !important;
    }
    /* Tab样式 */
    .tabs > .tab-nav { border-bottom: 1px solid rgba(255,255,255,0.1) !important; }
    .tabs > .tab-nav > button {
        color: #aaa !important; background: transparent !important;
        border: none !important; padding: 10px 20px !important;
        font-size: 0.95em !important; font-weight: 500 !important;
        border-bottom: 2px solid transparent !important;
    }
    .tabs > .tab-nav > button.selected {
        color: #00d2ff !important;
        border-bottom: 2px solid #00d2ff !important;
    }
    </style>

    <div style="text-align:center; padding:40px 20px 20px 20px;">
        <h1 style="font-size:2.2em; font-weight:700;
                   background:linear-gradient(90deg,#00d2ff,#7b2ff7);
                   -webkit-background-clip:text; -webkit-text-fill-color:transparent;
                   margin-bottom:8px;">
            🦴 骨骼动作识别系统
        </h1>
        <p style="color:#aaa; font-size:0.95em; margin:4px 0;">
            端到端骨骼序列分析与动作分类 Web Demo
        </p>
        <p style="color:#888; font-size:0.85em; margin:4px 0;">
            基于 ST-GCN · NTU RGB+D 60 · MediaPipe / mmpose
        </p>
    </div>
    """)

    with gr.Tabs():

        # ==================== 方案一：MediaPipe 3D 骨骼方案 ====================
        with gr.Tab("📱 MediaPipe 单目 3D 方案"):
            gr.HTML("""
            <div style="background:rgba(255,200,0,0.06); border:1px solid rgba(255,200,0,0.15);
                        border-radius:8px; padding:10px 14px; color:#aaa;
                        font-size:0.85em; margin:12px 0;">
                📱 基于 Google MediaPipe Pose 的单目 3D 骨骼提取方案。从 RGB 视频中估计 33 个关键点的三维世界坐标，
                映射为 NTU 25 关节格式后输入 ST-GCN 模型（Kinect 3D 数据训练, Top-1: 86.34%）。
                仅支持单人，实时性好，但存在跨域精度损失。
            </div>
            """)
            with gr.Tabs():
                # ----- 子Tab：视频动作识别 -----
                with gr.Tab("🎬 视频动作识别"):
                    with gr.Row(elem_classes="video-row"):
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">📹 上传动作视频（单人，.mp4，建议5-15秒）</div>')
                            mp_video_input = gr.Video(label="")
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">🦴 3D 骨骼动画</div>')
                            mp_video_output = gr.Video(label="")
                    with gr.Row(elem_classes="center-row"):
                        with gr.Column(scale=1, elem_classes="action-container"):
                            mp_video_btn = gr.Button("🚀 开始分析", variant="primary")
                            mp_video_status = gr.HTML(
                                value=make_status_html("等待上传视频 / Waiting for video upload...<br>分析过程约需30-60秒，请耐心等待<br>Analysis takes about 30-60 seconds, please wait.")
                            )
                    mp_video_btn.click(fn=process_video, inputs=mp_video_input, outputs=[mp_video_output, mp_video_status])

                # ----- 子Tab：骨骼数据提取 -----
                with gr.Tab("🦴 骨骼数据提取"):
                    with gr.Row():
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">📹 上传动作视频（单人，.mp4）</div>')
                            mp_conv_input = gr.File(label="", file_types=[".mp4", ".mov", ".avi", ".mkv"], elem_classes="conv-file conv-input")
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">📁 下载骨骼数据文件（NTU 25 关节 3D .pkl）</div>')
                            mp_conv_output = gr.File(label="", elem_classes="conv-file")
                    with gr.Row(elem_classes="center-row"):
                        with gr.Column(scale=1, elem_classes="action-container"):
                            mp_conv_btn = gr.Button("🦴 开始提取", variant="primary")
                            mp_conv_status = gr.HTML(
                                value=make_status_html("等待上传视频 / Waiting for video upload...")
                            )
                    mp_conv_btn.click(fn=video_to_pkl, inputs=mp_conv_input, outputs=[mp_conv_output, mp_conv_status])

                # ----- 子Tab：骨骼数据识别 -----
                with gr.Tab("🎯 骨骼数据识别"):
                    gr.HTML("""
                    <div style="background:rgba(0,210,255,0.05); border:1px solid rgba(0,210,255,0.15);
                                border-radius:8px; padding:8px 14px; color:#aaa;
                                font-size:0.85em; margin:12px 0;">
                        ✅ 上传 NTU 25 关节 3D 格式的骨骼数据文件（.pkl），使用 Kinect 3D 数据训练的
                        ST-GCN 模型进行动作识别（Top-1: 86.34%）。
                    </div>
                    """)
                    with gr.Row(elem_classes="center-row"):
                        with gr.Column(scale=1, elem_classes="pkl-panel"):
                            mp_pkl_input = gr.File(label="", file_types=[".pkl"], elem_classes="pkl-item")
                            mp_pkl_btn = gr.Button("🔍 开始识别", variant="primary", elem_classes="pkl-item")
                            mp_pkl_output = gr.HTML(value=make_status_html("等待上传文件 / Waiting for file upload..."), elem_classes="pkl-item")
                    mp_pkl_btn.click(fn=predict_from_pkl, inputs=mp_pkl_input, outputs=mp_pkl_output)

        # ==================== 方案二：mmdetection + mmpose (HRNet) 2D 方案 ====================
        with gr.Tab("🔬 mmdetection + mmpose (HRNet) 方案"):
            gr.HTML("""
            <div style="background:rgba(0,255,150,0.06); border:1px solid rgba(0,255,150,0.15);
                        border-radius:8px; padding:10px 14px; color:#aaa;
                        font-size:0.85em; margin:12px 0;">
                🔬 基于 mmdetection（Faster-RCNN R50）人体检测 + mmpose（HRNet-w32）2D 姿态估计方案。
                提取 COCO 17 关节 2D 坐标，配合专用 ST-GCN 模型（HRNet 2D 数据训练, Top-1: 89.0%）。
                支持多人动作，无跨域问题，识别精度更高，但推理速度较慢。
            </div>
            """)
            with gr.Tabs():
                # ----- 子Tab：视频动作识别 -----
                with gr.Tab("🎬 视频动作识别"):
                    with gr.Row(elem_classes="video-row"):
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">📹 上传动作视频（支持多人，.mp4，建议5-15秒）</div>')
                            mm_video_input = gr.Video(label="")
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">🦴 2D 骨骼叠加原视频</div>')
                            mm_video_output = gr.Video(label="")
                    with gr.Row(elem_classes="center-row"):
                        with gr.Column(scale=1, elem_classes="action-container"):
                            mm_video_btn = gr.Button("🔬 开始分析", variant="primary")
                            mm_video_status = gr.HTML(
                                value=make_status_html("等待上传视频 / Waiting for video upload...<br>mmpose 方案分析较慢，请耐心等待<br>mmpose analysis takes longer, please be patient.")
                            )
                    mm_video_btn.click(fn=process_video_mmpose, inputs=mm_video_input, outputs=[mm_video_output, mm_video_status])

                # ----- 子Tab：骨骼数据提取 -----
                with gr.Tab("🦴 骨骼数据提取"):
                    with gr.Row():
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">📹 上传动作视频（支持多人，.mp4）</div>')
                            mm_conv_input = gr.File(label="", file_types=[".mp4", ".mov", ".avi", ".mkv"], elem_classes="conv-file conv-input")
                        with gr.Column(scale=1):
                            gr.HTML('<div class="video-label">📁 下载骨骼数据文件（COCO 17 关节 2D .pkl）</div>')
                            mm_conv_output = gr.File(label="", elem_classes="conv-file")
                    with gr.Row(elem_classes="center-row"):
                        with gr.Column(scale=1, elem_classes="action-container"):
                            mm_conv_btn = gr.Button("🦴 开始提取", variant="primary")
                            mm_conv_status = gr.HTML(
                                value=make_status_html("等待上传视频 / Waiting for video upload...<br>mmpose 提取较慢，请耐心等待")
                            )
                    mm_conv_btn.click(fn=video_to_pkl_mmpose, inputs=mm_conv_input, outputs=[mm_conv_output, mm_conv_status])

                # ----- 子Tab：骨骼数据识别 -----
                with gr.Tab("🎯 骨骼数据识别"):
                    gr.HTML("""
                    <div style="background:rgba(0,210,255,0.05); border:1px solid rgba(0,210,255,0.15);
                                border-radius:8px; padding:8px 14px; color:#aaa;
                                font-size:0.85em; margin:12px 0;">
                        ✅ 上传 COCO 17 关节 2D 格式的骨骼数据文件（.pkl），使用 HRNet 2D 数据训练的
                        ST-GCN 模型进行动作识别（Top-1: 89.0%）。
                    </div>
                    """)
                    with gr.Row(elem_classes="center-row"):
                        with gr.Column(scale=1, elem_classes="pkl-panel"):
                            mm_pkl_input = gr.File(label="", file_types=[".pkl"], elem_classes="pkl-item")
                            mm_pkl_btn = gr.Button("🔍 开始识别", variant="primary", elem_classes="pkl-item")
                            mm_pkl_output = gr.HTML(value=make_status_html("等待上传文件 / Waiting for file upload..."), elem_classes="pkl-item")
                    mm_pkl_btn.click(fn=predict_from_pkl_mmpose, inputs=mm_pkl_input, outputs=mm_pkl_output)

    # ===== 模型信息 =====
    gr.HTML("""
    <div style="margin-top:30px; padding:20px;
                background:rgba(255,255,255,0.03);
                border:1px solid rgba(255,255,255,0.08);
                border-radius:16px;">
        <div style="text-align:center; color:#aaa; margin-bottom:14px;
                    font-size:1em; font-weight:600; letter-spacing:1px;">
            📊 模型与方案对比
        </div>
        <table style="width:100%; border-collapse:collapse; color:white;">
            <tr style="background:rgba(123,47,247,0.4);">
                <th style="padding:10px 16px; text-align:center; font-weight:600; border:1px solid rgba(255,255,255,0.1);">项目</th>
                <th style="padding:10px 16px; text-align:center; font-weight:600; border:1px solid rgba(255,255,255,0.1);">MediaPipe 3D 方案</th>
                <th style="padding:10px 16px; text-align:center; font-weight:600; border:1px solid rgba(255,255,255,0.1);">mmpose (HRNet) 2D 方案</th>
            </tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">骨骼提取</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">MediaPipe Pose</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">Faster-RCNN + HRNet-w32</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">关节格式</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">NTU 25 关节 3D（x,y,z）</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">COCO 17 关节 2D（x,y）+ score</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">支持人数</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">单人</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">多人（最多 2 人）</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">识别模型</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">ST-GCN（Kinect 3D 训练）</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">ST-GCN（HRNet 2D 训练）</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">模型 Top-1</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">86.34%</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">89.0%</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">跨域问题</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">有（MediaPipe ≠ Kinect）</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">无（提取与训练一致）</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">推理速度</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">较快（轻量级模型）</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">较慢（两阶段检测+估计）</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">训练数据集</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);" colspan="2">NTU RGB+D 60（60类 · Cross-Subject）</td></tr>
            <tr><td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);">深度学习框架</td>
                <td style="padding:10px 16px; text-align:center; border:1px solid rgba(255,255,255,0.08); background:rgba(255,255,255,0.03);" colspan="2">PyTorch 2.0.1 + PYSKL</td></tr>
        </table>
    </div>
    """)

if __name__ == "__main__":
    # 启动 Web 服务：屏蔽 gradio 自带的英文启动日志与版本升级提示，
    # 仅显示一行简洁的中文提示。prevent_thread_lock=True 让我们能够在启动后
    # 打印自己的提示，随后再用 block_thread() 阻塞主线程保持服务运行。
    with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
        app.launch(
            server_name="0.0.0.0",
            server_port=7860,
            share=False,
            quiet=True,
            show_api=False,
            prevent_thread_lock=True,
        )
    print("[系统] Web 服务已启动: http://0.0.0.0:7860")
    print("")
    print("=" * 68)
    print("        系统评价指标（Evaluation Metrics）")
    print("=" * 68)
    print("[指标] 评价协议（Protocol）: top_k_accuracy（Top-1 / Top-5）")
    print("[指标] 数据集（Dataset）   : NTU RGB+D 60，Cross-Subject 划分")
    print("-" * 68)
    print("[指标] 3D ST-GCN（NTU 25 关节）—— 本项目自训练，16 epoch")
    print("[指标]   · Top-1 准确率（Top-1 Acc） : 86.34%")
    print("[指标]   · Top-5 准确率（Top-5 Acc） : 97.33%")
    print("[指标] 2D ST-GCN（COCO 17 关节）—— PYSKL 预训练，8 GPU × 80 epoch")
    print("[指标]   · Top-1 准确率（Top-1 Acc） : 89.0%")
    print("=" * 68)
    try:
        app.block_thread()
    except (KeyboardInterrupt, OSError):
        pass