在线动作检测：实时识别正在发生的动作

可视化演示

定义与场景

解说员深吸一口气，他站在场边，眼睛一刻也不离开球场。他必须边看边说。他的工作有一个铁律：只能根据“已经看到的画面”来解说，绝不能提前说出“接下来会发生什么”——因为连球员自己都不知道下一秒会发生什么。解说员的这个工作原则，和 AI 的在线动作检测一模一样。

在线动作检测（Online Action Detection）就是指：系统持续接收流式视频帧，在每一帧到达的当下，仅依据当前帧及之前的历史帧，实时判断“当前正在发生什么动作”。它和离线动作识别最大的区别在于因果性——离线模型可以看完整段视频再回头标注“第 3 到第 8 秒在做深蹲”，而在线模型不能等，它必须像解说员一样语速飞快地吐出判断。

具体来说，在线动作检测要解决两个关键问题：第一，动作是否正在发生（检测动作的进行状态）；第二，动作何时开始、何时结束（时间边界的在线判定）。这天然对延迟提出了极高要求——从画面出现到系统给出判断，通常在几十到几百毫秒内完成，否则就失去了“实时”的意义。在直播审核（拦截违规画面）、智能安防（识别摔倒）、互动健身（纠正动作）等场景中，这个能力直接决定了产品的可用性。

1. 在线含义：“在线”意味着系统持续运行，每来一帧就要输出一次结果，像解说员一样不能停顿。

$$\text{输出}_{t}=f(x_{1},x_{2},\dots ,x_{t})$$

2. 历史信息约束：输出只依赖于当前及之前的帧，绝不含未来帧，这是因果性的技术表达。

$$\forall i>t:\; x_{i} \notin \text{输入集合}$$

部署一套在线动作检测系统，就像培训一位解说员：先让他看大量比赛录像学会识别动作（训练），然后让他上场边看边说（推理）。而这个“边看边说”的过程，正是接下来要拆解的每一步技术细节。

时序建模与特征

解说员凭什么一眼看出球员在做“射门”而不是“传球”？因为他不仅仅看某一瞬间的静止画面——他会把“助跑→摆腿→触球→球飞出去”这一连串的画面在脑中串联起来。这种把多帧画面串联起来理解的能力，在 AI 中叫时序建模。

要让机器具备这种能力，第一步是把每一帧视频变成一个机器能理解的“描述向量”，这叫帧级特征提取。现代做法通常用预训练的 2D/3D CNN 网络（如 ResNet、I3D）从每帧图像中提取特征向量，就像解说员用眼睛“扫描”画面，把“绿茵场、白色球衣、腿抬起来了”浓缩成一段数字描述。

但单帧特征只是“一张照片的摘要”，动作是连续时间上的变化，所以还需要时序上下文融合——把前后多帧的特征按时间顺序拼在一起，让模型看到“腿逐渐抬起又落下”的完整过程。常见特征还包括光流（描述像素在帧间的运动方向和速度，相当于解说员眼里的“动态轨迹”）和姿态特征（提取人体骨骼关键点坐标，相当于“球员骨架的逐帧位置”）。这些不同来源的特征可以拼接成更丰富的时序表示，就像解说员同时用眼睛追球、用余光看跑位一样，多路信息综合判断。

$$\mathbf{F}=[\phi(x_{1});\;\phi(x_{2});\;\dots ;\;\phi(x_{T})]$$

1. 逐帧提取：对每帧图像用卷积网络提取特征向量，得到该帧的“摘要”。

$$\phi(x_{i})\in \mathbb{R}^{d}$$

2. 时间拼接：把各帧特征沿时间轴排列成矩阵，形状为“序列长度 × 特征维度”。

$$[\cdot ;\cdot ]:\; \text{concatenation along time}$$

如果说特征是解说员“看到的信息”，那么时序建模就是解说员“串联信息的方式”。有了这个基础，下一步就要回答一个工程问题：解说员应该回看多远的过去来判断当下？这就是滑动窗口的由来。

滑动窗口机制

解说员虽然记性好，但不可能从比赛第 1 秒回忆到第 90 分钟——他只需要记得最近十几秒的场上形势，就能准确判断“现在发生了什么”。滑动窗口就是这个思路：每次只保留最近固定长度（比如 16 帧或 32 帧）的历史帧作为判断依据，窗口随新帧到来不断向前滑动。

滑动窗口的动机很朴素：动作本身是局部连贯的。“挥手”这个动作，你只需要看最近半秒的画面就能识别，不需要回忆上个月的事。固定窗口长度 L 意味着，时刻 t 的输入是窗口内的帧序列：

$$\mathbf{W}_{t}=\{x_{t-L+1},\dots ,x_{t}\}$$

窗口每来一帧就前移一步：丢弃最旧的一帧，纳入最新的一帧。这带来一个重要的工程特性——相邻窗口重叠度极高，只有一帧的差异。既然大部分帧在前后两次判断中都被重复用到，聪明的工程师会缓存中间计算结果，避免重复提取特征，大幅降低计算量。这与解说员“眼界始终维持在场上的近景”是同一个道理：他不是每句话都从头回忆，而是顺着记忆平滑地延续。

$$\text{重叠率}=1-\frac{1}{L}$$

1. 窗口长度 L：超参数，决定模型“记忆回看的范围”，像解说员的“近期记忆时长”。

$$\mathbf{W}_{t}\subseteq \{x_{1},\dots ,x_{t}\}$$

2. 滑动步长：通常每来一帧滑动一帧，保证输出的实时粒度。

$$\mathbf{W}_{t+1}=\mathbf{W}_{t}\setminus\{x_{t-L+1}\}\cup\{x_{t+1}\}$$

滑动窗口让解说员的“记忆”有了边界——他记住最近一段时间的画面，其余细节自然遗忘。但窗口不能无限长，因为解说员的嘴巴（判断速度）追不上无限回看。这就是为什么需要更聪明的记忆机制：不是所有信息都同等重要，有些瞬间必须刻骨铭心。

RNN在线推理

解说员记性其实很聪明：他不会平均用力记住每一帧，而是对关键瞬间（比如那记漂亮的倒挂金钩）记忆特别深刻，对平淡的传球瞬间一晃而过。这种“有选择地记住重要信息、自然地淡忘次要信息”的能力，正是循环神经网络（RNN）的核心天赋。

RNN 的核心思想是隐藏状态传递：它维护一个内部记忆向量 h（解说员的“脑内笔记”），每来一帧 x，就结合当前帧和上一时刻的记忆，更新出新的记忆，同时输出判断结果。用 LSTM 或 GRU 这样的门控 RNN，还能通过“输入门”“遗忘门”等机制，决定记住什么、忘掉什么——就像解说员会忘掉上个平淡回合的细节，但牢牢记住刚才那次越位争议。

RNN 对在线推理是天然友好的，因为它的计算是增量式的：时刻 t 的输出只依赖当前输入帧和上一步传递来的隐藏状态，不依赖早期所有帧的重新计算。这使得每来一帧，只需一次前向计算即可得到结果，计算量恒定，非常适合流式处理。简化的更新过程如下：

$$\mathbf{h}_{t}=\text{RNN}(\mathbf{h}_{t-1},\;\phi(x_{t}))\qquad \mathbf{y}_{t}=\text{Softmax}(\mathbf{W}\mathbf{h}_{t})$$

1. 隐藏状态更新：新记忆由旧记忆和当前帧共同决定，实现“增量式记忆刷新”。

$$\mathbf{h}_{t}=\tanh(\mathbf{W}_{h}\mathbf{h}_{t-1}+\mathbf{W}_{x}\phi(x_{t})+\mathbf{b})$$

2. 当前判断输出：从记忆状态解码出各类动作的概率分布，取最大者为判断结果。

$$\mathbf{y}_{t}=\text{softmax}(\mathbf{W}_{o}\mathbf{h}_{t}+\mathbf{b}_{o})$$

解说员凭借“脑内笔记”游刃有余，但 RNN 也有短板：记忆是串行传递的，看第 100 帧时必须先算完第 99 帧，难以并行。而且长距离依赖会衰减。这时，一位“过目不忘”的新解说员出现了——Transformer。

Transformer推理

想象一位天赋异禀的解说员，他的记忆方式完全不同：他不依赖“记笔记”，而是每当需要判断时，就把过去所有画面快速回放一遍，并且特别关注其中和当前时刻最相关的片段——比如判断“是否射门”时，他会重点回放“触球瞬间”的画面，而不是盯着守门员发呆。这种“全局回放 + 重点关联”的机制，就是 Transformer 的自注意力（Self-Attention）。

Transformer 在每一步推理时，计算当前帧（查询 Q）与历史所有帧（键 K）的相似度，再据此加权融合历史帧的信息（值 V）。这种机制能显式建模长距离依赖——第 1 秒的“助跑”信息可以跨越几十帧直接影响第 2 秒的“射门”判断，而不会被中间的无关帧冲淡。

但 Transformer 有个“犯规风险”：标准的自注意力会看到全局所有帧，包括未来帧——这等于解说员偷看了结果。所以在线推理必须加因果掩码（Causal Mask）：强制注意力只能关注当前及之前的帧，未来的位置全部置为负无穷，softmax 后权重归零。这相当于给解说员戴上一副“不透明眼罩”，只允许他回看过去。

$$\text{Attention}(Q,K,V)=\text{softmax}\left(\frac{QK^{\top}+M}{\sqrt{d_{k}}}\right)V,\qquad M_{ij}=\begin{cases}0 & j\leq i\\ -\infty & j>i\end{cases}$$

1. 相似度计算：当前帧与历史帧的点积除以维度平方根，得到“关联分数”。

$$\frac{QK^{\top}}{\sqrt{d_{k}}}$$

2. 掩码遮罩：未来位置的分数设为负无穷，softmax 后权重变为 0，杜绝偷看。

$$M_{ij}=-\infty \;(j>i)\;\Rightarrow \;\text{softmax}=0$$

Transformer 虽强，但“全局回放”成本不低——每次判断都把整个历史重新过一遍，计算量随时间线性增长。工程上常用 KV 缓存解决：把已经算好的键值对存起来，新帧只计算自己的 Q/K/V，与缓存的历史 K/V 做注意力，避免了重复计算，让推理速度大幅提升。

新的解说员过目不忘，但“回放全部画面”费时费力。到底该用记笔记的 RNN，还是用回放的 Transformer？这要看比赛的重要程度和你能接受的解说延迟——这就引出在线动作检测最核心的工程权衡：延迟与精度的跷跷板。

延迟精度平衡

解说员总在纠结：如果给他 1 秒时间回忆，他几乎不会说错；但观众要求他 0.2 秒内接话，他就只能凭直觉说个大概。在线动作检测面临同样的延迟-精度权衡：看的历史信息越多（窗口越长、模型越大、帧率越高），判断越准，但耗时就越多；反过来，追求低延迟就难免牺牲精度。

这条权衡关系可以画成一条精度-延迟曲线：横轴是端到端延迟（从画面出现到结果返回的毫秒数），纵轴是检测精度（如 mAP、准确率）。曲线通常呈上升趋势——延迟越高、精度越高，但会逐渐饱和。曲线的“甜点区”在拐点附近：再增加延迟，精度提升甚微，却白白浪费时间。

实操中做权衡有几个杠杆：第一，窗口长度——短窗口响应快但上下文不足，长窗口信息足但延迟高；第二，模型轻量化——用 MobileNet、轻量 Transformer 替换大模型，精度略降、速度倍增；第三，帧采样策略——不必每帧都推理，可以每隔 k 帧推理一次，中间帧沿用上次结果，把计算成本摊薄。

$$\text{延迟}\approx \underbrace{t_{\text{特征提取}}}_{\text{单帧耗时}}+\underbrace{t_{\text{时序推理}}}_{\text{窗口内计算耗时}}+\underbrace{t_{\text{传输/后处理}}}_{\text{固定开销}}$$

1. 特征提取耗时：单帧过 CNN 的时间，决定了每秒能处理多少帧。

$$t_{\text{feat}}=\text{latency of }\phi(x_{t})$$

2. 时序推理耗时：窗口内做 RNN/Transformer 推理的时间，与模型规模相关。

$$t_{\text{seq}}=\text{latency of RNN/Transformer on window}$$

解说员最终明白：不存在“又准又快”的免费午餐。接到什么解说任务，就配什么策略——体育直播要求最高实时性，就牺牲一点精度用轻模型；安防回查允许几秒延迟，就跑大模型换高精度。理清这笔账后，最后一步就是把这套系统真正“派上场”。

部署与优化实践

解说员的水平再高，也得坐到正确的转播席、戴上耳机、连好信号才能开口。在线动作检测模型训练得再好，也要解决上线部署的最后一公里：视频从哪里来？模型跑在哪里？出了问题怎么办？

首先是流式视频接入。常见做法是从 RTSP/RTMP 拉流或直接读取摄像头 SDK 输出的帧数据，做解码、缩放、归一化后送入模型。这一步要保证“帧不断流”，像解说员的耳机信号必须稳定——掉帧、卡顿会直接导致判断失败。实践中常用 FFmpeg 做视频解码与抽帧，通过队列缓冲实现拉流与推理的解耦。

其次是推理加速手段，梯次组合使用：用 TensorRT/ONNX Runtime 做模型编译优化，将 FP32 转成 FP16 或 INT8 量化，能获得 2-4 倍加速；对滑动窗口的重叠区域做特征缓存，避免重复计算；对多路视频流用 GPU 上的批处理（batching）进一步提升吞吐。像解说员会提前熟悉球队名单和战术一样，系统也要通过预热和缓存把“功课”做在前面。

然后是边缘端部署：在摄像头附近的小盒子（如 Jetson、树莓派 + NPU）上直接推理，省去视频上传云端的网络延迟，把“现场解说”变成“现场判断”。最后是监控与容错回退：系统要记录推理延迟、准确率漂移、模型置信度等指标，当延迟超阈值或置信度持续过低时，自动切换降级策略（比如降采样率、切备份模型），确保服务不中断。这套护栏就像导播台的应急预案——解说员嗓子哑了，立刻切备用麦克风。

从定义到部署，在线动作检测的完整链路就像培训一位解说员从观看录像、练习口播，到最终坐在直播间里面对真实比赛的整个过程。技术的每个环节，都在回答同一个问题：如何让 AI 边看边说，说得快，也说得好。

AI 应用场景

Python 演示

import numpy as npfrom collections import deque  class SlidingWindowDetector:    def __init__(self, window_len=16, frame_dim=2048, num_classes=5):        self.window_len = window_len        self.frame_dim = frame_dim        self.num_classes = num_classes        self.buffer = deque(maxlen=window_len)        self.hidden = np.zeros(256)        self.W_h = np.random.randn(256, 256) * 0.05        self.W_x = np.random.randn(256, frame_dim) * 0.05        self.W_o = np.random.randn(num_classes, 256) * 0.05        self.b_h = np.zeros(256)        self.b_o = np.zeros(num_classes)        self.feat_cache = {}        self.frame_count = 0     def extract_feature(self, frame_id):        if frame_id in self.feat_cache:            return self.feat_cache[frame_id]        # 模拟 CNN 提取特征: 此处用随机向量替代真实视频        feat = np.random.randn(self.frame_dim)        self.feat_cache[frame_id] = feat        return feat     def online_step(self, frame_id):        feat = self.extract_feature(frame_id)        self.buffer.append(feat)        if len(self.buffer) == self.window_len:            window = np.array(self.buffer)            for t in range(window.shape[0]):                self.hidden = np.tanh(                    self.W_h @ self.hidden + self.W_x @ window[t]                )            logits = self.W_o @ self.hidden + self.b_o            probs = np.exp(logits - logits.max())            probs = probs / probs.sum()            return int(np.argmax(probs)), probs        return None, None     def run_stream(self, total_frames=100):        events = []        for fid in range(total_frames):            action, probs = self.online_step(fid)            if action is not None:                events.append((fid, action, probs.max()))        return events  if __name__ == "__main__":    np.random.seed(42)    detector = SlidingWindowDetector()    results = detector.run_stream(200)    detected = [(fid, act) for fid, act, conf in results if conf > 0.5]    print(f"共推理 {len(results)} 次, 高置信事件 {len(detected)} 个")    for fid, act in detected[:5]:        print(f"帧 {fid}: 检测到动作类别 {act}")

1. deque(maxlen=window_len)用双端队列实现滑动窗口，自动丢弃最旧帧，正是“解说员只看最近一段记忆”的实现。
2. extract_feature模拟 CNN 帧特征提取，用 feat_cache 缓存已算特征，避免重叠窗口重复计算。
3. online_step每来一帧只做一次更新：把当前特征推进 RNN，不重新处理整个历史。
4. self.hidden = np.tanh(self.W_h @ self.hidden + self.W_x @ window[t])这就是 RNN 隐藏状态更新的核心：新记忆 = 旧记忆 + 当前帧。
5. logits = self.W_o @ self.hidden + self.b_o从隐藏状态解码出各类别得分，再 softmax 成概率。
6. run_stream模拟一整段流式视频逐帧喂入，输出每个时刻的动作判断。
7. conf > 0.5实践中常设置信度阈值过滤低可靠判断，减少误报。

常见误区

面试题