帧选择决定视频理解效果：多模态LLM关键帧抽取实战

很多刚开始做视频理解的开发者，很容易把注意力放在“用哪个多模态大模型”“Prompt 怎么写”上，结果真正跑下来才发现，效果好坏最关键的一步，其实是喂给模型的那些帧是怎么选出来的。换句话说，对于“让 LLM 看视频”这件事，帧选择（Frame Selection）几乎决定了整个任务的准确率上限。本文会从问题出发，讲清楚为什么不能直接把视频塞给 LLM，再给出一个完整的可复用方案，包含均匀采样、场景切换检测、CLIP 语义去重等策略的实现代码，以及让多模态大模型基于关键帧做分析的工程化思路。

1. 背景：为什么大模型“看”视频要先解决帧选择

1.1 多模态 LLM 的视频输入限制

目前的 LLM 虽然统一了文本、图片、音频等多种模态，但绝大多数模型仍然以“图像+文本”作为视频理解的基本单元。原因很简单：视频本质上是时间轴上的连续图像序列，同时叠加了音频、字幕等额外信息。直接让模型处理原始视频流，不仅会让输入 token 数量爆炸，也会让模型难以稳定捕捉关键语义。

为了控制输入规模，常规做法是把视频拆成图像帧序列，再交给多模态模型逐张或组合分析。也就是说，“让 LLM 看视频”实际上被拆解为两个环节：

1. 从视频中抽取若干帧；
2. 把帧和对应的文本 Prompt 一起交给 LLM。

第二个环节有大量现成工具和文档，但第一个环节往往被当作“预处理”一笔带过。在实际项目中，帧抽得不好，后续模型能力再强也很难补救。这里就引出了本文的核心观点：Frame selection is the whole game（帧选择就是整个游戏）。

1.2 直接抽帧的痛点

很多入门教程会给出类似cv2.VideoCapture每隔 N 帧保存一次的代码。这种思路确实简单，但在真实视频上会遇到几个明显问题：

• 信息冗余：连续帧之间画面高度相似，导致送入模型的 token 浪费在重复信息上；
• 关键瞬间丢失：均匀抽样可能正好漏掉动作变化、物体出现或场景切换的关键点；
• 上下文混乱：如果一帧中同时出现多个目标，模型很难理解它到底要回答什么问题；
• 成本过高：多模态模型的费用通常与输入图像数量成正比，抽得越多越贵，延迟也越高。

因此，帧选择不是简单的“压缩采样”，而是要在有限预算内，尽量保住影响任务结果的关键信息。这是视频理解工程必须面对的核心优化点。

1.3 本文的范围与目标

本文不会泛泛介绍“视频理解有哪些任务”，而是围绕一个具体目标展开：如何为 LLM 生成一组高质量的关键帧。适用场景包括：

• 视频问答（VideoQA）；
• 视频摘要与标题生成；
• 视频内容审核；
• 基于视频的 RAG 检索；
• 多模态 Agent 的视频理解前置模块。

读完本文，你应该能理解各种帧选择策略的适用场景，并搭建一个包含均匀采样、场景切换检测、语义去重三种策略的 Python 工具，后续可以接入任意多模态 LLM 使用。

2. 环境准备与版本说明

2.1 运行环境

本文示例代码在以下环境中验证：

• 操作系统：Ubuntu 22.04 / macOS 13+ / Windows 10+（均可运行）
• Python：3.9 及以上
• 主要依赖：OpenCV、NumPy、Transformers、Pillow

如果你使用的是本地大模型或多模态 API，请根据自己的实际接口调整调用部分。示例中的“OpenAI 兼容接口”只是演示切入口，具体模型参数需要按你使用的模型替换。

2.2 安装依赖

建议先创建一个干净的虚拟环境，再安装依赖。

python -m venv .venv source .venv/bin/activate # Windows 下使用 .venv\Scripts\activate

安装基础依赖：

pip install --upgrade pip pip install opencv-python numpy pillow

如果要做 CLIP 语义去重，需要安装 Transformers 和 Torch：

pip install torch torchvision transformers

安装完成后，可以快速验证 OpenCV 是否可用：

python -c "import cv2; print(cv2.__version__)"

需要说明的是，Transformers 和 PyTorch 的版本迭代较快。如果你已经安装过旧版本，建议先升级到比较新的版本，避免CLIPModel相关接口不兼容。

2.3 项目目录结构

为了让后续代码清晰，我们使用如下目录结构：

video_frame_selector/ ├── frame_selector/ │ ├── __init__.py │ ├── base.py │ ├── uniform.py │ ├── scene.py │ ├── clip_dedup.py │ └── pipeline.py ├── scripts/ │ ├── extract_frames.py │ └── analyze_with_llm.py ├── samples/ │ └── demo.mp4 └── output/ └── frames/

其中frame_selector是我们的核心代码库，scripts放置可执行脚本，output保存抽帧结果。你可以在项目根目录下创建这些文件夹：

mkdir -p video_frame_selector/frame_selector mkdir -p video_frame_selector/scripts mkdir -p video_frame_selector/samples mkdir -p video_frame_selector/output/frames

3. 帧选择的核心原理

3.1 均匀采样：最朴素的基线

均匀采样就是每隔固定时间间隔或帧数抽取一帧。它实现简单，适合时长较短、内容变化均匀的视频，比如访谈节目、固定机位直播等。

实现思路：

1. 读取视频总帧数和 FPS；
2. 根据目标帧数计算采样间隔；
3. 逐帧遍历并保存对应帧。

均匀采样的优点是开销低、代码简单；缺点是缺乏内容感知能力。如果一个视频前半段是静态画面，后半段是快速动作，均匀采样会把大量预算浪费在静止画面上，而快速动作阶段又可能只采到很少的帧。

因此，均匀采样更适合作为基线（baseline）和后续策略对比的参照对象。

3.2 场景切换检测：尊重视频内容结构

视频通常由多个镜头组成，镜头之间往往存在明显的亮度、颜色或内容突变。如果我们能找到这些边界，就可以在每个镜头内选取最有代表性的帧。

OpenCV 提供了createBackgroundSubtractorMOG2、calcHist等方法，也可以直接计算帧间差异。常见做法是计算连续帧的直方图差异或绝对像素差，差异超过阈值就认为发生了场景切换。

场景切换检测的优点是可以避免跨镜头混叠，让抽取的帧覆盖更多内容；缺点是对镜头内部的渐变、运动比较敏感，需要调阈值。

3.3 语义去重：用 CLIP 判断画面是否重复

CLIP（Contrastive Language-Image Pre-training）是一种把图像和文本映射到同一向量空间的模型。我们可以用 CLIP 为每一帧生成语义向量，然后计算相邻帧之间的余弦相似度，删除语义过于接近的帧。

这种方法的优势非常明显：

• 能识别“像素不同但语义相同”的重复画面；
• 不依赖具体的视频内容类型；
• 很容易和文本检索结合。

同时也要注意，CLIP 模型本身有一定计算开销。如果视频很长，不建议对每一帧都跑 CLIP，而是先在场景切换检测之后再对候选帧做语义去重。

3.4 综合策略：多信号混合选择

实际工程中，最佳做法不是只用一种策略，而是组合使用。常用流程是：

1. 用均匀采样或场景切换检测得到候选帧；
2. 对候选帧做 CLIP 语义去重；
3. 如果视频有字幕或音频转写文本，可以进一步根据文本内容挑选与问题最相关的帧；
4. 最后把剩余帧送入多模态 LLM。

这种“先粗筛、后细选”的思路，既能控制算力开销，又能保留内容多样性。下文实战部分会实现一个最小可用的综合 Pipeline。

4. 实战：编写一个可复用的视频帧选择器

4.1 定义帧选择器接口

为了避免代码堆在一起，我们为帧选择器定义统一接口。所有策略都实现select方法，输入视频路径和目标帧数，输出关键帧列表。

# 文件路径：video_frame_selector/frame_selector/base.py from abc import ABC, abstractmethod from dataclasses import dataclass from typing import List @dataclass class Frame: """关键帧对象，保存时间点和帧内容。""" index: int timestamp: float image: "numpy.ndarray" class BaseFrameSelector(ABC): """所有帧选择器的基类。""" def __init__(self, target_frames: int = 8): self.target_frames = target_frames @abstractmethod def select(self, video_path: str) -> List[Frame]: """从视频中选择关键帧。""" pass

这里定义了一个Frame数据类，包含帧序号、时间戳和图像数据。每个选择器只需要实现select方法即可。

4.2 实现均匀采样

均匀采样器是最简单的实现。它读取视频的 FPS 和总帧数，然后按时间间隔均匀取帧。

# 文件路径：video_frame_selector/frame_selector/uniform.py import cv2 from .base import BaseFrameSelector, Frame class UniformFrameSelector(BaseFrameSelector): """按固定时间间隔均匀采样，作为 baseline。""" def select(self, video_path: str) -> list[Frame]: cap = cv2.VideoCapture(video_path) total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) fps = cap.get(cv2.CAP_PROP_FPS) indices = self._generate_indices(total_frames) frames = [] current = 0 for idx in indices: cap.set(cv2.CAP_PROP_POS_FRAMES, idx) ret, frame = cap.read() if ret: timestamp = idx / fps frames.append(Frame(index=idx, timestamp=timestamp, image=frame)) current += 1 cap.release() return frames def _generate_indices(self, total_frames: int) -> list[int]: if total_frames <= self.target_frames: return list(range(total_frames)) step = total_frames // self.target_frames return [min(step * i, total_frames - 1) for i in range(self.target_frames)]

这里有一点值得注意：cap.set(cv2.CAP_PROP_POS_FRAMES, idx)在某些视频格式上可能定位不够精确。如果遇到抽出的帧与预期不符，可以改用逐帧读取并判断帧号的方式。

4.3 实现场景切换检测

下面使用帧间直方图差异来检测场景切换。具体做法是：

1. 把每一帧转为 HSV 颜色空间；
2. 计算颜色直方图；
3. 计算相邻帧的直方图相关距离；
4. 当距离超过设定阈值时，认为是新场景起点。

# 文件路径：video_frame_selector/frame_selector/scene.py import cv2 import numpy as np from .base import BaseFrameSelector, Frame class SceneChangeSelector(BaseFrameSelector): """通过直方图差异检测场景切换，在每个场景中取一帧。""" def __init__(self, target_frames: int = 8, threshold: float = 0.6): super().__init__(target_frames) self.threshold = threshold def select(self, video_path: str) -> list[Frame]: cap = cv2.VideoCapture(video_path) fps = cap.get(cv2.CAP_PROP_FPS) selected_frames = [] prev_hist = None frame_index = 0 while True: ret, frame = cap.read() if not ret: break hist = self._compute_hist(frame) if prev_hist is None: selected_frames.append(Frame(frame_index, frame_index / fps, frame)) prev_hist = hist else: score = cv2.compareHist(prev_hist, hist, cv2.HISTCMP_BHATTACHARYYA) if score > self.threshold: selected_frames.append(Frame(frame_index, frame_index / fps, frame)) prev_hist = hist frame_index += 1 cap.release() # 如果检测到的场景帧少于目标数，用均匀采样的帧补全 if len(selected_frames) < self.target_frames: indices = list(range(0, frame_index, max(1, frame_index // self.target_frames))) for idx in indices[: self.target_frames]: cap = cv2.VideoCapture(video_path) cap.set(cv2.CAP_PROP_POS_FRAMES, idx) ret, frame = cap.read() if ret: selected_frames.append(Frame(idx, idx / fps, frame)) cap.release() return selected_frames[: self.target_frames] @staticmethod def _compute_hist(frame: np.ndarray) -> np.ndarray: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) hist = cv2.calcHist([hsv], [0, 1], None, [50, 60], [0, 180, 0, 256]) cv2.normalize(hist, hist) return hist

阈值参数threshold需要根据视频内容调整。阈值越小，越容易将普通动作变化判定为场景切换；阈值越大，越容易漏掉真正的镜头切换。

4.4 实现 CLIP 语义去重

CLIP 语义去重的核心是：先用预训练模型把候选帧编码成向量，再通过两两比较或增量比较，保留语义差异较大的帧。

# 文件路径：video_frame_selector/frame_selector/clip_dedup.py import numpy as np from typing import List from .base import Frame class CLIPDedupFilter: """基于 CLIP 向量的语义去重过滤器。""" def __init__(self, similarity_threshold: float = 0.95): self.similarity_threshold = similarity_threshold self._model = None self._processor = None def _load_model(self): if self._model is None: from transformers import CLIPModel, CLIPProcessor model_name = "openai/clip-vit-base-patch32" self._model = CLIPModel.from_pretrained(model_name) self._processor = CLIPProcessor.from_pretrained(model_name) return self._model, self._processor def filter(self, frames: List[Frame]) -> List[Frame]: model, processor = self._load_model() images = [frame.image for frame in frames] # 使用 CPU / GPU 推理 import torch device = "cuda" if torch.cuda.is_available() else "cpu" model.to(device) inputs = processor(images=images, return_tensors="pt").to(device) with torch.no_grad(): image_features = model.get_image_features(**inputs) image_features = image_features / image_features.norm(dim=-1, keepdim=True) kept = [] kept_feature = None for frame, feature in zip(frames, image_features.cpu().numpy()): if kept_feature is None: kept.append(frame) kept_feature = feature else: similarity = np.dot(kept_feature, feature.T) if similarity < self.similarity_threshold: kept.append(frame) kept_feature = feature return kept

需要注意，这里的相似度阈值默认是 0.95，表示如果两帧 CLIP 向量余弦相似度超过 0.95，就认为语义重复。实际项目中需要根据自己的视频内容做调整。为了节省内存，建议传入 CLIP 去重器之前，先把候选帧缩放到较小尺寸，例如 224x224。

4.5 组装 Pipeline

把三种策略组合成一个 Pipeline。基本流程是：

1. 先用均匀采样得到一批候选帧；
2. 再用场景切换检测补充可能存在内容变化的帧；
3. 最后通过 CLIP 去重，保留语义差异大的帧。

# 文件路径：video_frame_selector/frame_selector/pipeline.py from typing import List from .base import Frame from .uniform import UniformFrameSelector from .scene import SceneChangeSelector from .clip_dedup import CLIPDedupFilter class FrameSelectionPipeline: """综合帧选择 Pipeline。""" def __init__(self, target_frames: int = 8, scene_threshold: float = 0.6, similarity_threshold: float = 0.95): self.target_frames = target_frames self.uniform_selector = UniformFrameSelector(target_frames) self.scene_selector = SceneChangeSelector(target_frames, scene_threshold) self.dedup_filter = CLIPDedupFilter(similarity_threshold) def run(self, video_path: str, use_clip: bool = True) -> List[Frame]: frames = [] frames.extend(self.uniform_selector.select(video_path)) frames.extend(self.scene_selector.select(video_path)) # 按时间戳排序并去掉相邻重复帧 frames = sorted(frames, key=lambda f: f.index) deduped = [] seen_ts = set() for frame in frames: ts = round(frame.timestamp, 2) if ts not in seen_ts: deduped.append(frame) seen_ts.add(ts) if use_clip and len(deduped) > self.target_frames: deduped = self.dedup_filter.filter(deduped) return deduped[: self.target_frames]

为了演示，这里没有刻意控制每个策略的帧数，而是采用“取并集 + 去重 + 截断”的思路。生产环境中，你还可以为每个策略设置不同的权重，或者根据视频时长动态调整策略组合。

5. 让多模态 LLM 分析关键帧

5.1 调用示例

帧选择完成之后，下一步是把关键帧交给多模态 LLM。我们以 OpenAI 兼容接口为例，演示如何构造请求。

# 文件路径：video_frame_selector/scripts/analyze_with_llm.py import base64 import os import cv2 from openai import OpenAI def encode_frame_to_base64(frame) -> str: """把 OpenCV 的 BGR 帧编码为 base64 字符串。""" ret, buffer = cv2.imencode(".jpg", frame) if not ret: raise ValueError("frame encoding failed") return base64.b64encode(buffer).decode("utf-8") def build_messages(frame_list, question: str): """ 构建多模态消息。 这里假设 API 支持图片 url 与 base64 data url。 """ content = [{"type": "text", "text": question}] for frame in frame_list: b64 = encode_frame_to_base64(frame.image) content.append({ "type": "image_url", "image_url": { "url": f"data:image/jpeg;base64,{b64}" } }) return [ { "role": "user", "content": content } ] def analyze_frames(frame_list, question: str, api_key: str = None): """调用 OpenAI 兼容接口进行分析。""" client = OpenAI( api_key=api_key or os.getenv("OPENAI_API_KEY"), ) response = client.chat.completions.create( model="gpt-4o", # 替换成你实际使用的多模态模型 messages=build_messages(frame_list, question), max_tokens=512, temperature=0.3, ) return response.choices[0].message.content

这段代码只是一个演示。如果你使用的是国内大模型或其他平台，请把client.chat.completions.create换成对应 SDK 的接口。

5.2 控制 Prompt 输出

多模态模型对多帧输入的理解能力很大程度上取决于 Prompt 描述。建议在 Prompt 中明确以下几点：

• 一共提供了多少帧；
• 帧与帧之间按时间顺序排列；
• 需要回答的具体问题；
• 输出格式要求。

示例 Prompt：

这是一段视频中的若干关键帧，按时间顺序排列。 请根据这些帧回答下面的问题： 问题：视频中的主角做了什么动作？ 要求： 1. 先描述你看到的画面； 2. 再给出结论； 3. 如果无法判断，请回答“信息不足”。

在build_messages中把上述 Prompt 放入text字段即可。

5.3 量化对比不同采样策略

为了直观感受帧选择的重要性，我们可以写一个简单的对比脚本，分别用均匀采样、场景切换、综合 Pipeline 抽取关键帧，再调用 LLM 做问答，最后人工或自动评估答案准确率。

下面是简化版的评估伪代码思路：

# 文件路径：video_frame_selector/scripts/evaluate_compare.py from frame_selector.uniform import UniformFrameSelector from frame_selector.scene import SceneChangeSelector from frame_selector.pipeline import FrameSelectionPipeline from analyze_with_llm import analyze_frames VIDEO_PATH = "samples/demo.mp4" QUESTIONS = [ "视频里出现了几个主要人物？", "主角最后去了哪里？", ] def evaluate(selector_name: str, frame_list, questions): print(f"=== {selector_name} ===") print(f"关键帧数量: {len(frame_list)}") for q in questions: answer = analyze_frames(frame_list, q) print(f"Q: {q}") print(f"A: {answer}") if __name__ == "__main__": uniform_selector = UniformFrameSelector(target_frames=8) scene_selector = SceneChangeSelector(target_frames=8, threshold=0.6) pipeline = FrameSelectionPipeline(target_frames=8) uniform_frames = uniform_selector.select(VIDEO_PATH) scene_frames = scene_selector.select(VIDEO_PATH) pipeline_frames = pipeline.run(VIDEO_PATH, use_clip=False) evaluate("均匀采样", uniform_frames, QUESTIONS) evaluate("场景切换", scene_frames, QUESTIONS) evaluate("综合Pipeline", pipeline_frames, QUESTIONS)

注意，这个脚本运行成本较高，会多次调用 LLM。实际对比时，建议先用固定的几个测试视频，并把结果记录到文本文件，再慢慢分析。

6. 常见问题与排查思路

在实际项目里，帧选择环节经常遇到的问题可以总结为以下几点。

7. 最佳实践与工程建议

7.1 用时间戳保留顺序信息

在把帧交给 LLM 之前，一定要保留帧的时间戳。很多模型对多帧输入的顺序并不敏感，因此你需要把时间戳放入 Prompt，或者把图片按时间顺序拼接成网格图，同时标注每帧所在的时间范围。

7.2 结合音频与字幕

视频理解不应该只依赖视觉信息。对于访谈、新闻类视频，字幕和音频转写文本往往包含大量关键信息。你可以把字幕文本作为一种弱信号，辅助帧选择。例如：

• 根据文本中的关键词定位相关时间段；
• 优先抽取这些时间段附近的帧；
• 将对应文本也交给 LLM。

这类“文本+视觉”混合策略，在长视频处理中效果提升非常明显。

7.3 控制图像分辨率与压缩率

多模态模型的输入图片通常会被缩放，你并不需要把原始高清帧全部上传。建议在抽帧后统一缩放到 512x512 或 768x768，不仅节省 token，还能提升推理速度。不过要注意，如果视频中有需要识别的小字、小目标，分辨率过低会导致信息丢失。

7.4 建立可评测的黄金数据集

帧选择策略好不好，不能靠感觉判断。建议先从你的业务场景中挑选 10 到 20 个代表性视频，人工标注“正确答案”，然后建立一个自动评估脚本。每次修改采样逻辑，都在固定数据集上重新评测，避免“修了一个问题又引入另一个问题”。

7.5 缓存抽取结果

视频抽帧是一个耗时操作。同一段视频，如果被多个任务复用，最好把抽取的关键帧保存到磁盘，并记录帧对应的视频路径、时间戳、策略参数。缓存结构可以参考：

cache/ video_demo_01/ uniform_8/ 00000.jpg 00033.jpg pipeline_8/ 00000.jpg 00088.jpg

这样后续做实验时，可以更快地对比不同策略，而不用反复解码视频。

7.6 设置异常兜底逻辑

视频文件可能损坏，也可能帧全部为黑屏。在 Pipeline 中需要设置兜底逻辑：如果抽取结果为空，就退化为均匀采样取前几帧；如果连视频都打不开，则记录错误日志并跳过本次任务。

# 示例：兜底逻辑 try: frames = pipeline.run(video_path, use_clip=True) except Exception as exc: print(f"Pipeline failed: {exc}, fallback to uniform") frames = uniform_selector.select(video_path)

8. 总结与下一步学习

帧选择决定了 LLM 看到的视频内容，也就决定了它最终能答出什么。仅仅把视频切割成若干帧是不够的，我们需要思考每帧是否包含信息增量，是否覆盖了关键动作，是否符合任务目标。均匀采样是一个简单可靠的基线，但真实业务项目中，建议把均匀采样、场景切换检测、CLIP 语义去重三者结合起来，再配合字幕、音频等文本信号做二次筛选。

如果继续深入，可以关注以下几个方向：

• 基于视频特征提取模型的实时帧选择，例如使用视频编码器计算帧级特征；
• 与 RAG 结合，把关键帧的视觉 embedding 存成向量索引，实现跨视频检索；
• 基于强化学习的动态采样策略，让模型在线决定下一步“看”哪一帧；
• 把帧选择器抽象成独立服务，供多个 LLM 应用复用。

如果你的项目也遇到了“模型明明很强，视频理解效果却很差”的问题，不妨先把注意力拉回到帧选择这一层。换一种采样策略，往往比换更大的模型更有效。