企业官网建设流程全解析

做了两年多的视频处理项目，我踩过的最大的坑，就是拿到一段 30fps 素材，想做成慢动作，结果画面一顿一顿，完全没法用。后来我把补帧、超分、去噪这些需求放到一起，慢慢整理出了一套以“HyperFrames”为核心的流程。严格来说，HyperFrames 并不是某一个软件的名字，而是一类围绕“超帧率”与“超帧联合处理”的视频技术方案的统称：它既包含用深度学习把低帧率视频插到 120/240fps 的帧插值，也包含把连续多帧打包成一个“超帧”后做联合降噪、去模糊、超分辨率复原的思路。这篇文章就是这套流程从原理、选型到落地的完整笔记，适合视频创作者、慢动作拍摄爱好者，也适合想在老片修复、监控分析、运动复盘里提升画面质量的从业者。

1. 项目整体设计与思路拆解

1.1 HyperFrames 到底是什么

先把这个词拆开看。Hyper 是“超越、超出”，Frames 是“帧、画面”，合起来就是“超越单帧”的处理方式。我理解的 HyperFrames 有两层含义：

• 超帧率（frame-rate up-conversion）：在已有连续帧之间生成原本不存在的中间帧，比如把 24fps 升到 60fps 甚至 240fps。
• 超帧（hyper frame）：把时间轴上连续的多帧当作一个整体处理单元，而不是一帧一帧单独修。这类似于 HDR 多帧合成、多帧降噪的思路，让算法能从前后帧里借用信息。

为什么要强调“超越单帧”？因为视频本质上是一个三维信号——二维空间加一维时间。如果你只盯着某一帧做画质处理，就相当于闭上一只眼看路，把时间轴上的冗余信息全浪费了。物体运动、环境变化、噪声在相邻帧之间的规律，只有在“多帧联合”的状态下才看得清楚。

举个例子，我想把一段老电影修复成高清版本。单帧超分模型确实能把分辨率拉高，但画面里的胶片噪声、压缩块效应、抖动会在每一帧都独立出现，结果修复后每一帧看起来都挺锐利，连起来一放，闪得眼花。换成 HyperFrames 的思路后，每 5 帧打包成一个超帧单元，让模型先做运动对齐，再联合去噪和超分，最后画面的时间一致性明显好了。这个“打包处理”的思路，就是整个项目的灵魂。

我以前见过不少朋友一听到补帧就说“用 SVP 不就好了吗，免费又简单”。SVP（SmoothVideo Project）确实方便，也能把 24fps 拉到 60fps，但在复杂运动、遮挡切换的场景下，SVP 的光流经常飞掉，出现明显的扭曲和鬼影。后来深度学习补帧模型成熟了，RIFE、RAFT 这类工具在精度和速度上远超传统光流插帧。我现在的方案是：普通场景用深度模型直接补帧，超帧修复场景用 VRT 这类的时域模型做联合处理，再配合 ffmpeg 做帧率规格化和音频对齐。整套流程需要的工具，其实也就是一台有独立显卡的电脑加一个 Linux 或 Windows 环境。

1.2 为什么把多帧捆成“超帧”而不是逐帧处理

逐帧处理视频看起来最符合直觉：视频不就是一堆图片吗，把每一张图片修好不就行了。但实际上，视频和图片最大的区别在于“帧间相关”。我们拍一段白天转夜晚的延时，连续帧之间的亮度和色温是渐变关系；拍一个人跑步，他的位置在帧间是平滑移动的。这些规律藏在多帧里，单帧根本拿不到。

拿“补帧”来说，如果只知道前帧和后帧，并且不做运动分析，那只能猜中间画面。最原始的对称平均会把两个画面叠在一起，任何有运动的地方都会出现重影。所以必须先用光流估计出运动方向，再按时间比例把物体“搬”到中间位置。这个过程天然是跨帧的，单帧处理完全无能为力。

再拿“多帧降噪”来说。相机的随机噪声在高感光度下非常明显，但噪声有一个特点：它是每帧独立随机出现的。把 4 帧相同场景求平均，信噪比就能提升约 6dB（因为噪声功率随帧数线性降低）。这个数学原理只在多帧联合时才成立。慢速快门的模糊也可以用多帧去卷积的思路补回来，前提还是多帧联合。

所以 HyperFrames 的核心方法，就是“宁可让处理单元变大，也要让模型看到时间上下文”。代价是显存和计算量成倍增长，换来的是质的飞跃。我的经验是，处理 1080p 视频时，如果单帧推理的显存占用是 2GB，那么一个包含 5 帧的超帧单元，合理优化后可能是 8GB，绝不是简单的 2GB 乘 5，因为模型内部要共享特征、做对齐，中间结果会更多。

1.3 方案选型：传统插帧、深度插帧与联合修复的取舍

我把实际用过的方案分成三类，用一张表说明取舍：

选型时我走过弯路。最早为了省事，直接用 SVP，配置完确实能流畅，但每次遇到快速甩动镜头，画面边缘就会出现像果冻一样的扭曲，观察动作运动时完全没法看。后来换成 RIFE 这类深度模型，默认 2 倍插帧，肉眼可见的画面干净程度完全不是一个量级。

RIFE 和 RAFT 的核心区别是，RAFT 更偏重精确的光流估计本身，RIFE 把光流网络和插帧网络放在一起端到端训练，直接优化中间帧的质量，所以推理时更快、更友好。但 RIFE 也不是万能的，它在遮挡区域的 mask 预测偶尔会把纹理抹平，快镜头大位移时依然会崩。所以我在实际流程里做了个分层策略：第一遍用 RIFE 做基础补帧，速度快；如果检测到某段连续帧的光流一致性特别低，就把这一段抽出来，改用更大尺寸模型或分块处理。

对于老片修复、监控视频增强这类场景，我强烈建议不要只做补帧，要在补帧之前或之后加一道超帧联合修复。VRT（Video Restoration Transformer）是目前我比较常用的模型，它用 Transformer 结构处理时域-空域信息，能一次性完成视频去模糊、去噪、超分。当然，它的权重文件很大，推理速度也比较慢，属于“质量优先”的路径。

2. 核心细节解析与实操要点

2.1 光流估计：视频补帧的最底层信号

光流（optical flow）是理解视频运动的核心概念。简单说，光流就是一张跟画面尺寸一样的图，每一格（像素）记录的是这个点在前后两帧之间移动了多少像素、朝哪个方向移动。

想象一下，你拍一个人在从左往右走。前帧里他的鼻子在屏幕坐标 (100, 200)，后帧里移动到了 (110, 200)，那光流图在 (100, 200) 这个位置的值就是“水平方向位移 +10 像素，垂直方向 0”。补帧时，我们要生成中间帧，就要知道物体在 0.5 时间点的位置，也就是 (105, 200)。如果没有光流，只能用全图平均，鼻子的位置和背景混在一起，就是重影。

光流估计有几个关键问题：

• 遮挡：前帧看得见的背景点，后帧被人物挡住了，光流在那里根本没有真实对应关系。模型只能靠猜。
• 大位移：如果物体一帧移动了几百像素，光流估计容易只捕捉到局部相似度，导致位移偏小。常见的处理是金字塔多尺度策略，从缩小很多倍的图算起，再逐层细化。
• 边界：图像边缘的像素移动出画面后，光流也无解。

RAFT 和 RIFE 里面的光流网络，都用了迭代优化的思路：先初始化一个全零或近似的光流，然后靠相关性查找不断地修正它，迭代几十次后收敛。RIFE 把迭代次数降低、网络宽度精简，换取了更快的推理速度。

实操层面的一个小心得：插帧前最好把视频里的上字幕、台标区域裁掉或做下遮罩。字幕是高频闪烁信息，光流会被它吸引，导致字幕附近出现周期性的波纹。我在处理综艺节目素材时踩过这个坑，后来养成习惯，先做黑边裁剪和字幕遮罩。

2.2 中间帧生成：从光流到新图像的完整推导

拿到前后两帧的光流后，怎么生成中间帧？这是整个项目里最需要理解清楚的部分。

假设前帧为 I0，后帧为 I1，要生成时间位置 t=0.5 的中间帧。最直观的做法是：

1. 估计 I0 到 I1 的前向光流 F0→1。
2. 估计 I1 到 I0 的后向光流 F1→0。
3. 用它们分别把 I0 和 I1 映射到 t=0.5 的位置，得到两个候选帧 M0 和 M1。
4. 用遮挡 mask 决定每个区域应该更相信哪个候选帧，或做一个加权融合。

用代码表达就是：

# 伪代码：基于光流的中间帧合成步骤 forward_flow = estimate_flow(frame_0, frame_1) # 0->1 backward_flow = estimate_flow(frame_1, frame_0) # 1->0 # 把前帧像素移到 t 时刻 candidate_0 = warp(frame_0, forward_flow * t) # 把后帧像素移到 t 时刻 candidate_1 = warp(frame_1, backward_flow * (1 - t)) # 检查前后向光流一致性，生成遮挡/置信度 mask occlusion_mask = compute_mask(forward_flow, backward_flow) # 融合候选帧 blend_mask = occlusion_mask * weight(t) middle_frame = blend_mask * candidate_0 + (1 - blend_mask) * candidate_1

这里有个细节：t 不一定总是 0.5。如果你要把 24fps 转成 60fps，一次插帧不够，可能要分成多个时间步。例如 24→60 是 2.5 倍，需要先补出 t=0.5 的帧，再补出 t=0.25 和 t=0.75 的帧，然后按时间顺序排列，最后再剪掉不需要的。

光流乘以 t 的 wapping 操作，在 PyTorch 里通常用grid_sample实现。要注意的是，网络输出光流的单位是“像素位移”，但如果输入图像尺寸和训练时不一致，光流量级会被放大或缩小，直接乘 t 可能产生偏差。所以推理时最好把输入图像尺寸对齐到训练设置，比如 RIFE 常见训练尺寸是 256/512 的整倍数，尽量让宽高能被 32 整除。

遮挡 mask 的判断也有讲究。如果某一个像素处的前向光流和反向光流对不上——比如前向说你向左走了 20 像素，后向却说你在原地——那这个位置大概率是遮挡区域。靠谱的流程会在这种位置完全采用未遮挡侧的候选帧，避免两个半透明鬼影叠在一起。

2.3 超帧联合处理：去噪、去模糊与时域超分辨率

补帧只是 HyperFrames 的其中一半。另一半是将连续帧组成“超帧”来做联合增强。

多帧降噪是最简单也最见效果的模式。假设你有 4 帧内容基本一致的照片，噪声是随机的，最简单的做法是把 4 帧像素相加再取平均，随机噪声会互相抵消，真实信号则保留下来。但视频里物体在动，不能直接平均，必须先把帧与帧之间做运动对齐。常用的对齐方法包括：

• 用光流 warp 到参考帧；
• 用 ECC（增强相关系数法）估计单应矩阵做全局对齐；
• 用深度学习中的可变形卷积对齐。

实际操作时，我常遇到“对齐不准导致边缘发虚”的问题。如果只是做监控场景多帧降噪，可以用全局 ECC 先校正摄像机本身的晃动，再用光流校正局部运动。如果做的是手持手机拍摄的素材，还要考虑 rolling shutter 造成的果冻效应，全局单应不够，局部光流也容易出错，这时候每帧做自适应变形是唯一靠谱的出路。

超帧去模糊的原理，简单说就是把多帧模糊图里的信息互补。物体在一帧里往左模糊，在下一帧里往右模糊，联合后可以得到更锐利的边缘。传统方法用维纳滤波或 Lucy-Richardson 反卷积逐帧处理，但容易产生振铃。现代深度模型如 VRT 会在注意力机制里显式建模多帧关系，效果要好很多。

超帧时域超分辨率更酷：用连续多帧的亚像素位移合成一张分辨率更高的图像。就像用普通手机连拍五张照片，因为手握不稳，每一帧画面都有微小位移，把这些错开的像素做高密度重建，理论上能突破单帧传感器的有效分辨率。这个思路在 DCRNet、BasicVSR 里都有体现。我试过把 480p 的监控录像裁切放大为 1080p 细节，单帧 SR 做出来是“修复过的猜测”，超帧 SR 做出来是“真的有更多细节”，差距非常大。

2.4 时间一致性：避免补帧后“一闪一闪”的进阶细节

很多人插帧后第一反应是“画面流畅了”，但仔细看会发现高速纹理区域像闪光灯一样“噼里啪啦”地闪。这就是时间一致性出问题。

原因在于：网络一帧一帧地独立生成中间帧，每一帧的预测都可能存在小幅度的随机错误。单独看某一帧你察觉不到，但放在时间轴上，错误随机跳动，就成了闪烁。

我的解决方案有三个层次：

• 输入层：每个超帧单元之间保留重叠帧。比如每 5 帧打包成一个组，下一组从第 3 帧开始，让模型在重叠区域保持上下文连续。
• 损失层：训练时加入时域损失，用感知模型同时对连续输出帧做特征提取，再计算特征差异，强制相邻帧在特征空间更接近。这属于模型再训练层面的优化。
• 后处理层：对插帧结果做时域滤波。可以检测像素级的变化曲线，把高频跳变拉平，但注意别把真实运动糊掉。

在实际部署中，最快见效的是“重叠超帧”方案。我在 VRT 修复老片时，组长度设为 5，重叠 2 帧，最终输出的闪烁明显降低。这个操作的额外代价只有多一些重复计算量，换来的是不用跑第二次后处理，很值得。

3. 实操过程与核心环节实现

3.1 环境准备：从零搭建补帧工具链

下面的流程以 Windows 11 + NVIDIA 显卡为例，Linux 也完全适用。第一步是把基础环境弄干净。

• Python 3.10 或 3.11；
• PyTorch 2.x + CUDA 11.8/12.1；
• FFmpeg（带 libx265 和 libx264）；
• Git、CMake（部分光流仓库编译需要）；
• 足够大的硬盘，我建议至少预留 200GB，因为抽帧后的 PNG 序列非常占空间。

我用 Anaconda 管理环境：

conda create -n hyperframes python=3.10 conda activate hyperframes pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121 pip install opencv-python numpy tqdm

数据集方面，训练插帧模型常用 Vimeo90K 或 Adobe 240fps 数据，但大多数读者是做推理，不是重新训练。我强烈建议先下载一个现成权重，比如 RIFE 官方发布的flownet.pkl或模型仓库里的rife*.pkl，然后写一个简单的推理脚本。

如果是新手，我建议先别想着训练自己的模型。用官方权重跑通流程，比什么都重要。这一步踩过坑的人知道，深度学习补帧的瓶颈往往不在模型结构，而在于输入输出的尺寸对齐、颜色空间处理和帧序处理。

3.2 基于RIFE的帧插值：核心代码与参数

我给出一个自用的推理流程，代码抽象了一点，方便你适配不同版本。

import torch import cv2 import numpy as np from model import RIFE # 以你下载的仓库为准 # 核心：两帧生成一帧 def make_interp(model, frame0, frame1, t=0.5, device='cuda'): f0 = preprocess(frame0).to(device) # torch.Size([1,3,H,W]) f1 = preprocess(frame1).to(device) with torch.no_grad(): # 多数 RIFE 版本接口是 model(f0, f1, timestep) pred = model(f0, f1, t) pred = (pred.squeeze(0).permute(1,2,0).clamp(0,1)*255).byte().cpu().numpy() return pred # 批量处理：每相邻帧对补出若干中间帧 def interpolate_clip(frames, times, model, device='cuda'): result = [] for i in range(len(frames) - 1): result.append(frames[i]) for t in times: if t != 0 and t != 1: result.append(make_interp(model, frames[i], frames[i+1], t)) result.append(frames[-1]) return result

这里的times是一个关键参数。我总结几种常见场景配置：

• 24fps 转 120fps，需要 4 倍帧率，中间时间点是[0.25, 0.5, 0.75]；
• 30fps 转 60fps，时间点是[0.5]；
• 30fps 转 240fps，时间点是[0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]。

注意，插帧倍数不是越高越好。8 倍插帧对光流压力极大，遮挡区域和快速运动区域会崩得很夸张。我的经验是，一次性最多做 4 倍，如果还需要更高帧率，就分两轮：第一轮 2 倍，第二轮再在结果上做 2 倍。虽然多一轮处理时间翻倍，但质量明显更稳。

补帧后的帧序列转回视频：

ffmpeg -framerate 120 -i output_%04d.png -c:v libx265 -crf 18 -preset medium output_120fps.mp4

这里用 -framerate 控制播放帧率，视频时长不变，只是帧数增多。如果是慢动作需求，可以把 framerate 设为素材原始帧率，比如 30fps 播放 120 帧的序列，播放时长就变成 4 倍。后续要说明的是，这种做法不会增加运动信息，是从已有动作轨迹中“猜”中间过程，需要用光流尽可能保证轨迹合理。

3.3 联合超帧修复与超分：以VRT为例

如果要把超帧联合修复加进流程，VRT 是目前比较实用的选择。它的官方仓库提供了不同的配置，比如VRT-VIDEO-SR和VRT-Denoising。部署的基本流程是：

先确认你的输入尺寸。VRT 内部有 8x8 patch 切分逻辑，输入宽高最好能被 8 整除，否则得做 pad。推理命令大致如下：

python basicsr/demo_video_sr.py \ --model_path model_zoo/VRT_ SR_8frames.pth \ --input inputs/movie_480p \ --output results/movie_1080p \ --num_frame 8

num_frame决定了超帧大小。这个参数直接关系显存占用：8 帧通常需要 16GB 显存才能轻松跑 720p，如果只有 8GB 显存，建议把num_frame降到 5，或者先把帧序列切成小块，分别处理后再拼起来。

拼接时最容易出问题的是边界处产生跳变。我在处理长视频时采用固定方案：每个超帧组覆盖 6 帧，但只保留中间 4 帧作为最终输出，其余 2 帧作为边界缓冲。这样拼接后的视频几乎看不到组间差异。

如果你不想碰深度学习模型，只做简单的多帧平均降噪，OpenCV 也能干活，但要接受效果上限：

import cv2 import numpy as np def multi_frame_denoise(image_list): # image_list 是已经对齐过的帧 stack = np.stack(image_list, axis=-1).astype(np.float32) mean = np.mean(stack, axis=-1) return mean.astype(np.uint8)

这个基础操作在光线极暗、画面静止的监控场景里非常有效。只要画面里有运动物体，直接平均就会糊，所以只建议在确认是静止场景时使用。

3.4 完整Pipeline拆解与质量评估

我的完整处理流程可以总结成以下几步：

1. 用 ffmpeg 把视频转成 PNG 帧序列；
2. 预处理：裁剪黑边、字幕遮罩、尺寸对齐；
3. 第一轮插帧：RIFE 2 倍或 4 倍；
4. 若需要画质修复：VRT 5 帧超帧联合去噪/超分；
5. 后处理：时间一致性修复，调整音轨；
6. 用 ffmpeg 输出为 H.265/H.264 成品。

做质量评估时，我绝不只看 PSNR。PSNR 对运动区域不敏感，经常出现指标很高、观感闪到爆的情况。我通常会同时看四种指标：

实际项目中，我建议再做一次“时间一致性检查”：把连续两帧输出做差，看差异图的能量是否异常。正常视频在平滑区域差异应该很小，只有运动边缘才有明显变化。如果差异图全是雪花点，说明每帧都在独立“创新”，这个问题比 PSNR 低更严重。

我的经验数字供参考：在 RTX 3090 上，720p 视频 2 倍补帧大约每秒能处理 30 帧输入；4K 视频只能做到每秒 5 帧左右。如果你们用的是 RTX 3060 这类 8GB 显卡，建议不要直接挑战 4K 8 倍，老老实实先做 1080p 2 倍，把流程跑通再优化。

4. 常见问题与排查技巧实录

4.1 遮挡区域鬼影频出

现象：人物身后背景本应被挡住，却在中间帧里透过来一半；或者边缘出现半透明拖影。

原因就是光流在遮挡区域根本没有可靠对应关系，模型只能猜。我的排查顺序：

• 先看是不是前后帧差异太大，如果位移超过画面宽度的 1/10，就不要硬插，先做 2 倍分段插；
• 检查遮挡 mask，RIFE 这类模型有可选的 mask 输出，如果 mask 过于均匀，说明模型没学到遮挡，这属于训练问题；
• 最直接的兜底：把中间帧改为“只取前帧的刚性 warp”和“只取后帧的刚性 warp”，用边缘检测判断哪个更合理。

经验之谈：遮挡问题靠后处理很难完全解决，与其疯狂调参，不如换个模型。RIFE 的某个版本对遮挡 mask 做了强约束，效果比早期版本好很多，优先用新版本权重。

4.2 复杂纹理高频闪烁

现象：草地、树叶、细条纹区域在插帧结果里像水波一样颤抖。

这其实是时间一致性问题。高频纹理区域像素梯度大，光流估计的微小误差就会导致中间帧的位置偏差几个像素，连续播放就成了抖动。

处理办法：

• 降低插帧倍数，从 4 倍降到 2 倍；
• 插帧前对图像做轻微高斯模糊，减少高频干扰，但别把细节全抹掉，推荐核尺寸 3 或 5；
• 输出前做一次时域中值滤波，针对像素级闪烁很有效，但要注意保留运动边缘。

如果纹理闪烁只出现在某一段，我会把那一段单独提取出来，换用一个更强调时间一致性的模型重新处理。

4.3 大位移场景光流失效

现象：镜头快速横移、人物快速入画出画，补帧画面忽大忽小、边缘拉伸。

大位移是光流估计的经典难题。RAFT 用多尺度迭代缓解了大部分问题，但仍有极限。

我的应对是“三明治策略”：

1. 先把帧序列做时间方向的高斯金字塔下采样，生成不同运动速度的层；
2. 在低层（运动速度慢）建立可靠光流；
3. 把低层光流放大后作为上层初始值，再在高分辨率上细化。

如果没有程序实现，最简单的替代方案是“分段插帧”：一次只插一个中间点，相当于把大位移拆成几个小位移。比如直接从 frame0 到 frame20 插帧几乎必炸，但先插 0→10，再插 0→5 和 10→15，成功率会大幅提升。

4.4 显存不足与性能瓶颈

我最早用 8GB 显存跑 1080p 4 倍补帧，直接 Out of Memory。排查后发现问题不只是显存小，还犯了两个低级错误：

• 没有开torch.no_grad()，推理时保留了梯度图，浪费大量显存；
• 没有用混合精度，半精度推理能省一半显存，并且现代 GPU 上速度更快。

正确姿势：

torch.set_grad_enabled(False) model.half().cuda()

注意，如果输入图像是 uint8 转 float，要记得转成 half，否则类型不匹配。PyTorch 2.x 的自动混合精度也能用，但插帧模型通常结构简单，直接 half 更稳。

如果仍然爆显存，就该上分块推理。把一张 1080p 图切成四个 512x512 的小图，各自补帧，再拼接。关键是相邻块要留 16~32 像素重叠，并在拼接处做羽化融合，否则分块边界会有一条明显的缝。

4.5 输出时长、帧数与音画同步

这个坑特别典型：插帧后帧数变成原来的 N 倍，但如果 ffmpeg 输出时没把 framerate 调对，要么视频播放飞快，要么音画不同步。

记住一个公式：

• 输出视频帧率 = 原视频帧率 × 插帧倍数；
• 视频时长不变，帧数呈倍数增加；
• 音频保持原来的时间长度，不需要额外处理。

例如 24fps 素材补到 96fps，输出时-framerate 96，音频不变，时长一致。如果你想要慢动作效果，输出 framerate 仍设为 24，时长变成 4 倍，这时音频如果保留就会和画面错位，要做变速或丢弃音频。

实际操作时，我习惯先把音频抽出来，等视频处理完毕再根据需求合回去：

ffmpeg -i input.mp4 -map 0:a -c copy audio.m4a # 处理视频后... ffmpeg -i processed.mp4 -i audio.m4a -c:v copy -c:a aac -shortest final.mp4

4.6 常见问题速查表

写在最后的个人体会

我现在处理任何视频项目，都会第一时间问一句：要不要上 HyperFrames。如果是自媒体短视频，2 倍补帧配合剪辑软件自带的慢动作就够；如果是运动复盘、老片修复、监控取证，我更愿意花两三个小时跑完整套超帧流程。我个人在实际操作中的体会是：补帧最怕的不是 GPU 不够强，而是把补帧神化。很多人以为有了 AI 插帧，24fps 素材就能轻松变 120fps，但实际上，源素材的清晰度、快门角度、运动模糊量才是决定补帧质量的天花板。拍摄时如果光线允许，我会尽量提高快门速度，减少每帧的运动模糊，这样后期补帧时信息更干净。最后再分享一个小技巧：插帧之前先用肉眼拉一遍视频，找出快速甩镜头、遮挡剧烈的片段，手动切掉或跳段处理，比让模型硬扛整个文件有效得多。后续如果大家对 RIFE 的自定义训练、VRT 的模型微调感兴趣，我还可以把这部分单独展开写一篇，那又是另一个故事了。