告别昂贵动捕设备：手把手教你用M2FP+Python搭建免费运动员动作分析系统

你是否曾对职业体育团队那些动辄数十万的动作捕捉系统望而却步？那些布满反光标记点的紧身衣、环绕场地的红外摄像机，似乎将精准的生物力学分析隔绝在了高昂的成本壁垒之后。但技术的民主化浪潮正在改变这一切。今天，我们不再需要依赖Vicon或OptiTrack这样的专业硬件，仅凭普通的摄像头和一台性能尚可的电脑，就能构建一套属于你自己的、具备专业级分析潜力的运动员动作分析系统。这并非天方夜谭，而是基于开源深度学习模型M2FP（Mask2Former for Human Parsing）与Python生态的巧妙结合。本文的目标读者，正是那些预算有限但创意无限的体育培训机构技术员、高校实验室的研究生，或是渴望将AI技术应用于体育领域的个人开发者。我们将一起，从零开始，搭建一个能够解析视频、分割人体部位、并提取关键运动特征的全流程分析工具。

1. 理解核心：为什么是M2FP，而不是关键点检测？

在开始动手之前，我们必须厘清一个核心概念：为什么选择基于人体解析（Human Parsing）的M2FP，而不是更常见的姿态估计（Pose Estimation）模型，例如OpenPose或MediaPipe的Pose？

传统的姿态估计模型输出的是人体的一系列关键点坐标，比如左肩、右肘、左膝等。这些点构成了一个“火柴人”骨架。这种方法速度快、计算量相对小，但对于精细的动作分析，它丢失了大量信息。

想象一下分析一个体操运动员的落地动作。关键点模型只能告诉你脚踝和髋关节的坐标，但无法告诉你运动员足部的具体姿态（是前脚掌着地还是全脚掌？）、小腿肌肉的紧张程度（通过轮廓形态间接反映）、乃至衣物摆动所暗示的缓冲过程。这些细节对于评估落地稳定性和损伤风险至关重要。

M2FP走的是另一条技术路线：语义分割。它不满足于只找到几个点，而是致力于为图像中的每一个像素分配一个标签，指明这个像素属于人体的哪个具体部位。最终，你会得到一张“分区地图”，上面清晰地标出了头部、躯干、左上臂、右下腿等连续的区域。

M2FP在体育分析中的独特优势：

• 丰富的几何信息：获得的是连续的二维区域，而非孤立的点。你可以计算肢体的质心、面积、朝向、甚至轮廓的曲率。
• 更强的抗遮挡能力：在团队运动中，运动员相互遮挡是常态。M2FP基于Transformer的架构（Mask2Former）在理解全局上下文方面表现优异，即使身体部分被遮挡，也能根据可见部分和周围环境进行合理推断。
• 形态学特征提取：区域掩码（Mask）能反映肢体的粗细、形态变化。例如，通过分析跑步视频中大腿区域掩码的周期性变化，可以间接评估步幅和肌肉发力模式。
• 与场景融合分析：M2FP同时分割“背景”，使得我们可以更容易地将运动员从场地中分离出来，便于后续的轨迹跟踪或与场地标线进行位置关联。

为了更直观地对比，我们看下面这个表格：

特性维度	关键点检测模型 (如 OpenPose)	人体解析模型 (M2FP)
输出形式	稀疏的2D/3D坐标点集合	稠密的像素级类别标签图
信息密度	较低，仅关节位置	极高，包含肢体形状、轮廓、面积
抗遮挡性	一般，遮挡严重时关键点易丢失	较强，能利用上下文进行补全
计算开销	相对较低	相对较高
适合场景	实时姿态跟踪、基础动作分类	精细动作分析、生物力学研究、异常检测
数据衍生	角度、速度、加速度	角度、面积、质心轨迹、形态学参数

对于追求深度分析而非实时反馈的体育科研或训练评估场景，M2FP提供的“面”信息远比“点”信息更有价值。它让我们从“知道关节在哪”进化到“理解身体如何构成和运动”。

2. 搭建你的专属分析引擎：从零部署M2FP服务

理论清晰后，我们进入实战环节。我们的目标是搭建一个本地运行的M2FP推理服务，它可以通过Web界面或API接收图片，并返回分割结果。考虑到目标用户群可能没有高性能GPU，我们将全程以CPU环境为基准进行优化配置。

2.1 环境配置：避开版本“深坑”

深度学习项目对环境依赖非常敏感，版本不匹配是新手最大的噩梦。根据大量社区实践反馈，我们锁定了一套在CPU上稳定运行的“黄金组合”。请严格按照以下步骤操作。

首先，创建一个干净的Python虚拟环境，这是保证依赖隔离的好习惯。

# 创建并激活虚拟环境
python -m venv m2fp_sports
# Linux/macOS
source m2fp_sports/bin/activate
# Windows
m2fp_sports\Scripts\activate

接下来，安装核心依赖。请注意PyTorch版本，这是稳定性的关键。

# 安装PyTorch CPU版本 (1.13.1是关键版本，能避免后续推理中的tuple索引错误)
pip install torch==1.13.1+cpu torchvision==0.14.1+cpu -f https://download.pytorch.org/whl/cpu

# 安装MMCV，这是许多计算机视觉模型的基础库
pip install mmcv-full==1.7.1 -f https://download.openmmlab.com/mmcv/dist/cpu/torch1.13/index.html

# 安装ModelScope，阿里开源的模型管理框架，M2FP模型托管于此
pip install modelscope==1.9.5

# 安装其他必要工具库
pip install flask opencv-python pillow numpy requests

注意：mmcv-full的安装需要指定与PyTorch和CPU环境对应的版本URL，上述命令已针对PyTorch 1.13.1 CPU做了适配。如果网络环境导致下载慢，可以考虑使用国内镜像源。

2.2 构建简易推理API服务

我们不打算直接使用复杂的训练代码，而是编写一个轻量的Flask应用来提供模型服务。创建一个名为 app.py 的文件。

from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks
from modelscope.outputs import OutputKeys
import cv2
import numpy as np
from PIL import Image
import io
import base64
from flask import Flask, request, jsonify
from concurrent.futures import ThreadPoolExecutor
import logging

# 配置日志
logging.basicConfig(level=logging.INFO)
app = Flask(__name__)

# 全局加载模型 (较耗时，启动时加载一次)
logging.info("正在加载M2FP模型，请稍候...")
human_parsing_pipeline = pipeline(
    task=Tasks.human_parsing,
    model='damo/cv_resnet101_image-human-parsing',
    device='cpu' # 指定使用CPU
)
logging.info("模型加载完毕！")

# 创建一个线程池，用于处理并发请求（即使CPU环境，I/O等待时也能处理多请求）
executor = ThreadPoolExecutor(max_workers=2)

def run_parsing(image_pil):
    """在独立线程中运行模型推理"""
    try:
        result = human_parsing_pipeline(image_pil)
        parsing_result = result[OutputKeys.MASKS]  # 获取分割掩码图
        # 掩码图是单通道的，每个像素值代表类别ID
        return parsing_result
    except Exception as e:
        logging.error(f"推理失败: {e}")
        return None

@app.route('/health', methods=['GET'])
def health_check():
    return jsonify({"status": "ready"})

@app.route('/predict', methods=['POST'])
def predict():
    if 'image' not in request.files:
        return jsonify({'error': '未提供图像文件'}), 400

    file = request.files['image']
    # 读取并转换图像
    image_stream = io.BytesIO(file.read())
    image_pil = Image.open(image_stream).convert('RGB')

    # 可选：调整图像尺寸以加速推理，保持宽高比
    max_size = 640
    w, h = image_pil.size
    if max(w, h) > max_size:
        scale = max_size / max(w, h)
        new_w, new_h = int(w * scale), int(h * scale)
        image_pil = image_pil.resize((new_w, new_h), Image.Resampling.LANCZOS)

    # 提交推理任务到线程池
    future = executor.submit(run_parsing, image_pil)
    parsing_mask = future.result()

    if parsing_mask is None:
        return jsonify({'error': '模型推理出错'}), 500

    # 将单通道掩码转换为可视化的彩色图（便于查看）
    # 这里使用一个简单的颜色映射，实际类别更多
    color_map = [
        [0, 0, 0],       # 0: 背景 - 黑
        [128, 0, 0],     # 1: 头发 - 深红
        [0, 128, 0],     # 2: 头 - 深绿
        [128, 128, 0],   # 3: 上衣 - 橄榄
        [0, 0, 128],     # 4: 下装 - 深蓝
        [128, 0, 128],   # 5: 左臂 - 紫
        [0, 128, 128],   # 6: 右臂 - 青
        [128, 128, 128], # 7: 左腿 - 灰
        [64, 0, 0],      # 8: 右腿 - 暗红
        [192, 0, 0],     # 9: 左鞋 - 红
        [64, 128, 0],    # 10: 右鞋 - 黄绿
    ]
    # 确保颜色映射足够长
    while len(color_map) <= np.max(parsing_mask):
        color_map.append([np.random.randint(0,255) for _ in range(3)])

    h, w = parsing_mask.shape
    color_mask = np.zeros((h, w, 3), dtype=np.uint8)
    for idx, color in enumerate(color_map):
        color_mask[parsing_mask == idx] = color

    # 将原图与彩色掩码图水平拼接，方便对比
    original_np = np.array(image_pil)
    # 调整掩码图大小与原图一致（如果之前resize了）
    if original_np.shape[:2] != color_mask.shape[:2]:
        color_mask = cv2.resize(color_mask, (original_np.shape[1], original_np.shape[0]))
    vis_image = np.hstack([original_np, color_mask])

    # 将结果图像编码为base64返回
    _, buffer = cv2.imencode('.png', vis_image[:, :, ::-1]) # RGB转BGR for cv2
    img_str = base64.b64encode(buffer).decode('utf-8')

    return jsonify({
        'image': f'data:image/png;base64,{img_str}',
        'mask_shape': parsing_mask.shape,
        'unique_labels': np.unique(parsing_mask).tolist()
    })

if __name__ == '__main__':
    # 设置Flask和线程池参数，优化CPU使用
    # 启用多线程，并绑定到所有网络接口
    app.run(host='0.0.0.0', port=5000, threaded=True)

保存文件后，在终端运行：

python app.py

如果一切顺利，你会看到“模型加载完毕！”的日志，服务将在 http://localhost:5000 启动。你可以通过访问 http://localhost:5000/health 来检查服务状态，或者使用下面的Python脚本测试 /predict 接口。

2.3 测试与批量处理脚本

创建一个 test_client.py 来测试API，并演示如何批量处理视频帧。

import requests
import cv2
import os
import time

def process_video(video_path, output_dir, api_url="http://localhost:5000/predict", frame_interval=5):
    """
    处理视频文件，每隔几帧抽取一帧进行分析。
    :param video_path: 输入视频路径
    :param output_dir: 分割结果保存目录
    :param api_url: M2FP API地址
    :param frame_interval: 抽帧间隔（数字越大，处理帧越少）
    """
    os.makedirs(output_dir, exist_ok=True)

    cap = cv2.VideoCapture(video_path)
    frame_count = 0
    processed_count = 0

    while True:
        ret, frame = cap.read()
        if not ret:
            break

        if frame_count % frame_interval == 0:
            # 将帧保存为临时图片文件用于发送
            temp_path = f"temp_frame_{processed_count}.jpg"
            cv2.imwrite(temp_path, frame)

            with open(temp_path, 'rb') as f:
                files = {'image': f}
                try:
                    response = requests.post(api_url, files=files, timeout=30)
                    if response.status_code == 200:
                        result = response.json()
                        # 这里可以保存返回的base64图片，或者直接处理mask数据
                        # 简单示例：打印信息
                        print(f"处理第{frame_count}帧成功，掩码形状：{result['mask_shape']}")
                        # 实际应用中，应解析并保存mask用于后续分析
                    else:
                        print(f"处理第{frame_count}帧失败：{response.text}")
                except requests.exceptions.RequestException as e:
                    print(f"请求API出错: {e}")

            os.remove(temp_path) # 清理临时文件
            processed_count += 1
            time.sleep(0.1) # 避免请求过于频繁

        frame_count += 1

    cap.release()
    print(f"视频处理完成。总帧数：{frame_count}， 处理帧数：{processed_count}")

# 使用示例
if __name__ == '__main__':
    # 请替换为你的视频路径
    # process_video("input_football.mp4", "output_parsing")
    # 也可以测试单张图片
    test_image_path = "test_athlete.jpg"
    if os.path.exists(test_image_path):
        with open(test_image_path, 'rb') as f:
            files = {'image': f}
            resp = requests.post("http://localhost:5000/predict", files=files)
            if resp.status_code == 200:
                print("单张图片测试成功！")
                # 可以将返回的图片数据保存下来查看
                import base64
                from PIL import Image
                import io
                result = resp.json()
                img_data = result['image'].split(',')[1]
                img = Image.open(io.BytesIO(base64.b64decode(img_data)))
                img.save('test_result.png')
                print("结果已保存为 test_result.png")
    else:
        print("请准备一张测试图片并命名为 test_athlete.jpg")

至此，你的本地M2FP解析引擎已经搭建完成。它虽然运行在CPU上，速度可能不如GPU，但对于分析预先录制的训练视频、进行离线深度分析来说，已经完全可用。

3. 从像素到洞察：如何利用分割结果进行动作分析

得到人体部位的分割掩码（Mask）只是第一步，就像拥有了矿石，我们需要从中提炼出黄金——即具有体育分析价值的特征。本节将介绍几种从M2FP输出中提取量化特征的方法。

3.1 基础特征提取：角度、质心与姿态

假设我们已经获得了一帧图像的分割掩码 mask，这是一个二维数组，每个位置的值代表像素所属的身体部位类别（如0背景，1头发...）。我们可以利用OpenCV和NumPy来大展身手。

1. 计算肢体角度（以肘关节为例） 要计算肘关节角度，我们需要上臂和前臂的掩码。假设类别5是左上臂，13是左前臂（具体类别ID需根据模型定义确认，这里仅为示例）。

import cv2
import numpy as np

def calculate_limb_angle(mask, upper_limb_id, lower_limb_id):
    """
    计算两个相连肢体区域形成的夹角。
    通过计算两个区域掩码的质心，并利用向量夹角公式得到角度。
    """
    # 获取肢体区域的二值掩码
    upper_mask = (mask == upper_limb_id).astype(np.uint8)
    lower_mask = (mask == lower_limb_id).astype(np.uint8)

    # 计算质心 (moments方法)
    M_upper = cv2.moments(upper_mask)
    M_lower = cv2.moments(lower_mask)

    if M_upper['m00'] == 0 or M_lower['m00'] == 0:
        return None # 区域可能被遮挡或不存在

    cx_upper = int(M_upper['m10'] / M_upper['m00'])
    cy_upper = int(M_upper['m01'] / M_upper['m00'])
    cx_lower = int(M_lower['m10'] / M_lower['m00'])
    cy_lower = int(M_lower['m01'] / M_lower['m00'])

    # 假设关节点位于两个质心之间，我们可以用质心连线近似肢体轴线
    # 向量1: 从“肩点”（近似为上臂质心）到“肘点”（近似为上下臂质心中点）
    # 向量2: 从“肘点”到“腕点”（近似为下臂质心）
    # 简化计算：直接计算上臂质心到躯干某点（如颈部）和下臂质心到上臂质心的向量
    # 这里需要一个稳定的参考点，例如躯干质心。
    # 更稳健的方法是结合姿态估计关键点，但这里演示掩码质心法。

    # 示例：计算上臂向量和下臂向量（假设已知肩关节坐标 shoulder_pt）
    # shoulder_pt = (sx, sy) # 这需要从其他方法获得，例如用躯干和上臂掩码推算
    # vec_upper = np.array([cx_upper - sx, cy_upper - sy])
    # vec_lower = np.array([cx_lower - cx_upper, cy_lower - cy_upper])

    # 计算向量夹角
    # dot_product = np.dot(vec_upper, vec_lower)
    # norm_upper = np.linalg.norm(vec_upper)
    # norm_lower = np.linalg.norm(vec_lower)
    # cos_angle = dot_product / (norm_upper * norm_lower + 1e-6)
    # angle_rad = np.arccos(np.clip(cos_angle, -1.0, 1.0))
    # angle_deg = np.degrees(angle_rad)

    # 由于缺少精确关节点，此处返回质心位置作为演示
    return (cx_upper, cy_upper), (cx_lower, cy_lower)

# 使用示例
# upper_centroid, lower_centroid = calculate_limb_angle(parsing_mask, upper_limb_id=5, lower_limb_id=13)
# if upper_centroid:
#     print(f"上臂质心: {upper_centroid}, 前臂质心: {lower_centroid}")

2. 评估躯干倾斜度 躯干的倾斜对于跑步、骑行等运动的效率分析很重要。我们可以通过拟合肩部连线和髋部连线的角度来估算。

def estimate_trunk_inclination(mask, left_shoulder_id, right_shoulder_id, left_hip_id, right_hip_id):
    """
    通过肩部和髋部区域的水平位置，估算躯干倾斜角。
    这是一个简化方法，更精确需要拟合中线。
    """
    # 获取各部位掩码并计算质心X坐标
    def get_centroid_x(mask_area):
        M = cv2.moments(mask_area.astype(np.uint8))
        if M['m00'] == 0:
            return None
        return int(M['m10'] / M['m00'])

    ls_x = get_centroid_x(mask == left_shoulder_id)
    rs_x = get_centroid_x(mask == right_shoulder_id)
    lh_x = get_centroid_x(mask == left_hip_id)
    rh_x = get_centroid_x(mask == right_hip_id)

    if None in [ls_x, rs_x, lh_x, rh_x]:
        return None

    # 计算肩线中点和髋线中点的X坐标差
    shoulder_center_x = (ls_x + rs_x) / 2
    hip_center_x = (lh_x + rh_x) / 2

    # 假设图像中Y轴向下，这里计算的是水平方向的偏移，可用于判断侧倾
    # 更完整的计算需要Y坐标来求实际角度
    horizontal_shift = shoulder_center_x - hip_center_x
    # 这是一个相对的、像素单位的偏移量，可用于序列比较
    return horizontal_shift

# 假设类别ID，需要根据实际模型调整
# shift = estimate_trunk_inclination(mask, 9, 10, 15, 16)
# print(f"躯干侧向偏移（像素）: {shift}")

3.2 时序特征与动作模板匹配

单帧分析价值有限，体育动作是连续的。我们需要将多帧的特征串联成时间序列。

构建时间序列数据：

import pandas as pd

# 假设我们处理了一个视频序列，得到多帧的特征列表
frame_features = [] # 列表，每个元素是字典，包含帧号和各类特征
# 例如： {'frame': 0, 'left_elbow_angle': 120.5, 'trunk_shift': -5.2, ...}

# 转换为DataFrame便于分析
df = pd.DataFrame(frame_features)
df.set_index('frame', inplace=True)

# 简单的平滑处理（移动平均）
df_smoothed = df.rolling(window=3, center=True, min_periods=1).mean()

# 现在df_smoothed包含了平滑后的动作时序数据

动态时间规整（DTW）进行动作匹配： DTW是衡量两个时间序列相似度的经典算法，非常适合比较动作，即使他们的速度不同。

from dtaidistance import dtw # 需要安装： pip install dtaidistance
import numpy as np

# 假设我们有一个“标准投篮”的肘关节角度序列
standard_shot_elbow_angle = np.array([...]) # 标准序列

# 以及一个待检测的运动员序列
athlete_elbow_angle = df_smoothed['left_elbow_angle'].values

# 计算DTW距离
distance = dtw.distance(standard_shot_elbow_angle, athlete_elbow_angle)
print(f"与标准投篮动作的DTW距离: {distance}")

# 距离越小，动作越相似。可以设定一个阈值来判断动作是否“标准”
threshold = 10.0
if distance < threshold:
    print("动作符合标准投篮模式。")
else:
    print("动作与标准模式存在较大偏差。")

通过组合空间特征（角度、质心）和时间分析（序列、DTW），我们就可以对复杂的体育动作进行量化评估和分类，例如识别投篮、起跑、游泳划水等动作阶段。

4. 实战案例：构建一个篮球投篮动作评估原型

让我们将前面所有知识串联起来，设计一个简单的篮球投篮动作分析原型。这个系统将分析一段投篮视频，评估其准备阶段的身体稳定性。

分析目标：

1. 识别投篮准备姿势：当球员屈膝、举球至出手点前时。
2. 评估身体对称性：计算准备姿势时左右肩的高度差和左右髋的高度差，评估身体是否平衡。
3. 计算出手角度：粗略估算球出手时大臂与躯干的夹角。

步骤分解：

第一步：视频预处理与关键帧提取。 我们不再逐帧分析，而是寻找“投篮准备”和“出手瞬间”两个关键帧。一个简单启发式规则是：当双手区域的质心Y坐标（图像上方为小）接近头部区域质心Y坐标时，可能处于举球位置。

def find_key_frames(video_path, parsing_api_url, interval=10):
    """扫描视频，寻找潜在的投篮关键帧索引"""
    cap = cv2.VideoCapture(video_path)
    key_frame_indices = []
    frame_idx = 0

    while True:
        ret, frame = cap.read()
        if not ret:
            break
        if frame_idx % interval == 0:
            # 调用API解析当前帧
            # ... (发送frame到/predict接口，获取解析结果)
            # 假设从结果中得到了头部和双手的掩码
            # head_mask, left_hand_mask, right_hand_mask = ...

            # 计算双手合并质心Y和头部质心Y
            # hand_centroid_y = (left_hand_cy + right_hand_cy) / 2
            # head_centroid_y = head_cy
            # if abs(hand_centroid_y - head_centroid_y) < threshold:
            #     key_frame_indices.append((frame_idx, 'preparation'))
            pass # 实际代码需填充
        frame_idx += 1
    cap.release()
    return key_frame_indices

第二步：对关键帧进行详细特征提取。 找到准备帧后，我们提取详细特征：

def analyze_preparation_frame(parsing_mask):
    """分析准备帧的身体姿态"""
    features = {}

    # 1. 肩部平衡性 (假设类别ID: 左肩9， 右肩10)
    left_shoulder_mask = (parsing_mask == 9)
    right_shoulder_mask = (parsing_mask == 10)
    left_shoulder_cy = cv2.moments(left_shoulder_mask.astype(np.uint8))['m01'] / max(cv2.moments(left_shoulder_mask.astype(np.uint8))['m00'], 1)
    right_shoulder_cy = cv2.moments(right_shoulder_mask.astype(np.uint8))['m01'] / max(cv2.moments(right_shoulder_mask.astype(np.uint8))['m00'], 1)
    features['shoulder_height_diff'] = abs(left_shoulder_cy - right_shoulder_cy)

    # 2. 髋部平衡性 (假设类别ID: 左髋15， 右髋16)
    # ... 类似计算 ...

    # 3. 膝盖弯曲程度 (通过腿部掩码的宽高比或质心位置粗略估算)
    # 腿部掩码(左腿17，右腿18)的质心Y与髋部质心Y的差值可以反映弯曲程度
    # ...

    return features

第三步：生成可视化报告。 使用Matplotlib或OpenCV将分析结果标注在原图上，并生成一个简明的文本报告。

def generate_report(key_frame_features, output_image_path):
    """生成分析报告和可视化图像"""
    img = cv2.imread('path_to_key_frame.jpg') # 加载关键帧图片
    # 在图像上绘制特征点、连线、标注数值
    # cv2.circle, cv2.line, cv2.putText ...

    report_text = f"""
    投篮准备姿势分析报告：
    - 肩部水平差： {key_frame_features['shoulder_height_diff']:.1f} 像素 (越小越好)
    - 髋部水平差： {key_frame_features['hip_height_diff']:.1f} 像素
    - 预估膝盖弯曲指数： {key_frame_features['knee_bend_index']:.2f}
    """
    # 将报告文本保存为.txt文件
    with open('shot_analysis_report.txt', 'w') as f:
        f.write(report_text)

    cv2.imwrite(output_image_path, img)
    print(f"分析完成！可视化结果已保存至 {output_image_path}， 报告已保存。")

这个原型系统虽然简单，但清晰地展示了从原始视频到可量化、可解释的教练辅助信息的完整链路。你可以在此基础上，增加更多的特征（如肘关节角度、出手速度估算等），并利用更多数据训练一个分类器，来自动判断投篮动作的“优良中差”。

整个流程跑下来，你可能已经感受到了在CPU上处理视频的耗时。这引出了最后一个重要话题：性能优化。对于个人或小团队，处理短视频片段（如10秒的投篮动作）是可行的。对于更长视频，可以考虑在抽帧策略（frame_interval参数）上做文章，或者利用云服务按需调用GPU资源。更进阶的，可以探索将模型转换为ONNX格式并使用ONNX Runtime进行推理，通常能获得比原生PyTorch CPU更快的速度。另一个思路是使用更轻量级的骨干网络（如MobileNet）版本的解析模型，在精度和速度之间取得平衡。我在实际测试中发现，对于强调上身动作的分析（如投篮、网球发球），适当降低图像输入分辨率（如从640x480降到320x240）对关键特征提取影响不大，但能显著提升处理速度。