长视频理解：让AI看懂一小时的视频

可视化演示

展示连续分配、链接分配和索引分配三种磁盘文件分配策略的磁盘块布局，对比碎片化程度和访问效率。

长视频挑战

周五晚上，你打开一部三小时的电影。看到第 40 分钟，手机震了一下——你回完消息再抬头，屏幕里主角正在和反派对峙，你一脸茫然：他们为什么打起来？这就是“上下文丢失”。AI 看长视频时也一样：它的小本本（上下文窗口）翻到最前面，第一次出现的关键线索早就被冲掉了。一小时的视频，按每秒一帧抽取就是 3600 帧，每帧再转成几百个 token，总量轻松破百万，而模型的小本本只有几万页——根本记不下。

“记不下”是长视频理解的第一难点。视频本身是高度冗余的，相邻帧几乎一样，但关键转折可能就藏在某一帧里。模型既不能把全部帧都吞进去，又不能随便丢掉可能的关键帧。真正的矛盾在于：上下文窗口有限，而有效信息稀疏地散布在漫长的时序中。

用框架的眼光看，标准注意力机制要求每帧与所有帧两两比较，计算成本随帧数平方增长：

所以长视频理解的第一步，不是“看得更多”，而是“聪明地少看”——先承认记忆有限，再用分层、记忆、检索这些技巧安排有限的注意力。真正会看电影的人，不会逐帧背诵，而是记住关键情节点，随时准备回放。

分层建模

你会怎么向朋友推荐一部三小时的长片？你不会从头到尾逐帧复述，而是先说“这是一个复仇故事”，再挑两三场重头戏讲细节。AI 也是这样：直接用完整序列做精细理解的代价太高，不如先粗后细——先看懂“段落在讲什么”，再深入具体情节。这套思路就是分层建模。

分层建模的第一层是“分段聚合”。把视频切成 8~16 秒的小段，每段内几百帧先压成一个段级特征；第二层再把这些段特征按时间顺序交给全局模型。因为段的数量远远小于帧的数量，全局模型处理起来就轻松多了。这也契合人看片的习惯：眼睛每秒接收 24 帧，大脑记住的却是一幕幕“场景”。

分段聚合最朴素的实现，是取窗口内所有帧特征的均值：

当然，生产系统不会只用均值。更成熟的做法是第一层用小型视觉模型捕捉局部动作和物体，第二层用时序模型建模段与段之间的关系，第三层才做全局推理。层级越高，看得越“粗”，但视野越“广”。就像看电影：先记住几个章节名，再回忆每章的转场，最后才去抠每句台词——信息一层层收敛，但骨架始终在。

记忆机制

看三个小时的电影，你不可能把每句台词都背下来，但你会边看边记笔记：“第 12 分钟，女主拿到神秘钥匙”“第 80 分钟，钥匙打开地下室”——到结尾时，你靠这本笔记回答“钥匙到底有什么秘密”。模型同样需要这样一本笔记，术语叫记忆池。

记忆机制要回答三个问题：记什么、怎么更新、忘什么。记什么：只记录有信息量的片段，比如场景切换、人物入场、关键动作，而不是把每一帧都塞进去。怎么更新：新信息到来时，与记忆池中旧内容做融合——最近的情节通常会覆盖或修饰之前的记忆。

记忆更新最经典的形式是“指数滑动平均”：

除了滑动更新，工程上常用的还有“摘要记忆”：每当窗口满了，就用一个小模型把窗口内容写成一句摘要存进记忆池；如果记忆池满了，再按重要性丢弃最不重要的摘要。这就像观影笔记写满一页后，你会划掉无关紧要的支线，把主线越写越粗。好的记忆机制不是硬盘无限大，而是像人一样——有取舍地记。

片段检索

电影看到结尾，你想回放“雨中分别”那场戏。你不会从头加速重看，而是直接拖动进度条到大约 90% 的位置——因为你记得那场戏快结束时出现。模型也一样：当用户问“主角什么时候发现真相”时，模型不会把一小时视频重新看一遍，而是先定位到记忆池中最相关的几段，再精确检索。

这个过程就是片段检索，包含三步：关键帧定位、索引构建、粗排精排。关键帧定位：在每个视频段中挑出能代表整段的帧，比如画面变化最大的那一帧。索引构建：将这些关键帧的特征向量做成索引表（如向量数据库），查询时先快速筛出候选。

候选排序最常用的度量是余弦相似度：

粗排用轻量的近似最近邻索引从几百万候选里筛出几百个，精排才用重模型对这几百个做精细打分。这和你下载电影的搜索框是一样的：先按片名粗筛，再对比海报和简介精挑。长视频理解里，检索就是模型的“进度条”——它决定了回答一个问题是秒回还是要等一分钟。

高效注意力

看足球比赛时，你的目光不会均匀扫过每一寸草皮——球在哪里，视线就在哪里。看长视频也一样：模型没必要对每一帧的每一个像素都给予相同关注，只需要把注意力集中在当前关键事件周围。如果注意力机制还是平方复杂度，一小时视频根本处理不动，所以必须让注意力“偷懒”，而且有策略地偷懒。

高效注意力家族里有三兄弟。局部窗口注意力：只看前后 $k$ 帧，完全不管远距离——相当于你盯着球附近的球员。稀疏注意力：在局部之外，每隔一段距离采样一帧参与计算——相当于用余光扫一眼远处有没有人跑位。线性注意力：用核技巧把注意力矩阵分解，把复杂度从 $O(L^2)$ 压到 $O(L)$——相当于不再两两配对，而是每个人先跟“裁判”汇报，再由裁判汇总。

广义上，稀疏注意力写成“只对部分键做 softmax”：

局部窗口保留细节，稀疏采样照顾全局，线性变换提速——三者结合，长视频模型才真正能在可接受的成本内“看完”整部片子。就像解说员不会反复描述草坪，只会跟着球讲：观众该看到的细节一个不少，冗长的空档全部跳过。

长上下文

再好的记忆机制，也有个前提：模型得记住“位置”。如果模型不知道第 2 分钟和第 100 分钟谁先谁后，情节因果关系就全乱了。位置编码就像是给视频每一帧贴上“第几分钟”的标签，让注意力机制知道“谁是前面的伏笔、谁是后面的高潮”。

经典的做法是 Transformer 里的正弦位置编码：用一组周期性变化的数值来标记每个位置的“时间戳”。更关键的是，训练时模型只见过 4096 个位置，推理时却要处理 100 万个位置——位置编码如果不会“外推”，就越界崩掉。长上下文技术要做的事，就是让模型在没见过的更长位置上依然表现正常。

正弦位置编码的公式：

工程上除了这类编码外推，还有更务实的上下文管理：把视频分成若干段落，每段一个摘要指纹，全局推理时只加载最相关的几段摘要进上下文；或者用 KV 缓存复用技术，让已算过的帧特征不重复计算。这就像你看一本厚书，不是把所有页码全部背下来，而是记住目录和关键章节的页码，需要时再翻到对应页。长上下文不是“无限内存”，而是“聪明的内存调度”。

应用落地

铺垫完理论，回到真实世界：一个影视公司要你做一个“AI 看片助手”，把两小时的电影自动生成剧情梗概、高光片段时间戳和角色关系图。你会如何设计？答案是：把前面六节串成一条流水线——抽帧、分层、记忆、检索、注意力压缩，最后再针对业务做输出。

以电影分析为例，流水线长这样：输入影片 → 抽帧（每秒 1 帧）→ 第一层小模型识别镜头和场景 → 第二层时序模型按段落生成剧情摘要 → 记忆池浓缩全局 → 用户提问时触发片段检索，定位具体桥段 → 生成最终报告。整个过程不再是“一次性读完全片”，而是“边看边整理笔记，随时按需翻页”。

评估这类系统的效果，不能只看“回答得像不像”，要看“关键片段找得准不准”。业界常用 F1 分数：

部署时还要注意推理成本：长视频的特征抽取极其昂贵，常用做法是离线把视频切段、提前抽好特征存向量库，用户提问时只做检索和轻量推理；在线则用流式框架逐段消费视频，边接收边压缩，用户等到结束时已经拿到了记忆池。让 AI 真正“看懂一小时视频”，需要的不是一个更大的模型，而是一条聪明的流水线和一把好用的“进度条”。

AI 应用场景

Python 演示

import numpy as npfrom collections import deque  class HierarchicalVideoMemory:    """分层长视频理解：滑动窗口 + 压缩记忆池 + 片段检索"""     def __init__(self, window=10, capacity=8, dim=64):        self.window = window          # 滑动窗口长度        self.capacity = capacity      # 记忆池容量        self.dim = dim                # 特征维度        self.short_term = deque()     # 短期窗口        self.memory_pool = []         # (importance, vector)        self._step_count = 0     def feed_frame(self, frame):        # 注入一帧特征        self.short_term.append(frame)        self._step_count += 1        if len(self.short_term) >= self.window:            segment = np.mean(self.short_term, axis=0)            fused = self._fuse_context(segment)            self._write_memory(fused)            self.short_term.clear()     def _fuse_context(self, segment):        # 与最相关记忆融合，保留时序信息        if not self.memory_pool:            return segment        top = self.memory_pool[0][1]        return 0.7 * segment + 0.3 * top     def _write_memory(self, segment):        # 按重要性保留前 capacity 条记忆        importance = float(np.linalg.norm(segment))        self.memory_pool.append((importance, segment))        self.memory_pool.sort(key=lambda x: x[0], reverse=True)        del self.memory_pool[self.capacity:]     def retrieve(self, query, top_k=3):        # 余弦相似度检索最相关记忆        scores = [np.dot(query, m) / (np.linalg.norm(query) *                  np.linalg.norm(m) + 1e-8) for _, m in self.memory_pool]        order = np.argsort(scores)[::-1][:top_k]        return order.tolist()     def global_summary(self):        # 全局总结：加权记忆 + 关键片段        total_w = sum(w for w, _ in self.memory_pool) + 1e-8        vec = sum(w * m for w, m in self.memory_pool) / total_w        return {            "summary_len": len(self.memory_pool),            "key_moments": self.retrieve(vec),        }  if __name__ == "__main__":    rng = np.random.default_rng(42)    mem = HierarchicalVideoMemory(window=10, capacity=8, dim=64)    # 模拟 120 秒视频，每秒 1 帧    for i in range(120):        frame = rng.random(64)        if i % 25 == 0:            frame += 3.0  # 模拟关键事件特征增强        mem.feed_frame(frame)    result = mem.global_summary()    print("memory size:", result["summary_len"])    print("key moments:", result["key_moments"])

1. def feed_frame(self, frame):每来一帧就注入系统，窗口满了自动触发一次段级汇总。
2. segment = np.mean(self.short_term, axis=0)把窗口内所有帧特征取平均，得到“这一小段讲了什么”。
3. fused = self._fuse_context(segment)与当前最重要记忆做加权融合，让段信息带上历史语境。
4. self.memory_pool.sort(key=lambda x: x[0], reverse=True)按重要性降序排列，保证记忆池永远保留最重要的条目。
5. del self.memory_pool[self.capacity:]超出容量的一刀切掉，模拟“遗忘”。
6. np.dot(query, m) / (np.linalg.norm(query) * np.linalg.norm(m) + 1e-8)余弦相似度，判断用户问题和哪条记忆最贴近。

常见误区

面试题