简介：本资源面向计算机、人工智能、通信工程等专业的在校学生与教师，以及希望进阶超分辨率技术的开发者，提供一套基于EDVR、SRCNN、FSRCNN的完整部署方案，并配套matlab、python与tkinter图形界面，可用于毕业设计、课程设计或项目初期立项演示。压缩包共702个文件，约334.22MB，其中566个png与20个bmp为训练测试图像，40个mat与22个avi为数据集与视频素材，22个m脚本与4个py文件构成核心算法与界面逻辑，另有8个exe、6个xml及若干txt、md说明文件，便于快速理解工程结构。目前已有187人学习下载。代码均经测试运行成功，答辩评审平均分达96分，读者可获取完整源码、界面交互逻辑与超分辨率模型部署思路，并在此基础上修改扩展功能，适合小白进阶与毕设参考。

1. 从一堆 avi 到能跑的超分工程：这套 EDVR/SRCNN/FSRCNN 资源到底值不值得拆

如果你手头正好有一批 calendar.avi 、 foliage.avi 、 walk.avi 、 city.avi 这类低分辨率视频片段，又不想从零去啃 BasicSR 的配置体系，那这套基于 MATLAB / Python / Tkinter / BasicSR 的超分辨率部署资源，基本就是为你准备的。它把 EDVR、SRCNN、FSRCNN 三条技术路线塞进同一个可运行工程里，前端用 Tkinter 做交互，后端挂 BasicSR 的推理管线，输入输出直接对着 avi 视频文件。适合做毕设、课设、图像处理大作业的人，也适合想快速验证「视频超分到底能不能落地」的工程师。我拆完的第一感受是：它不是玩具 demo，而是一个把算法、界面、数据流串起来的完整闭环，坑有，但都能填。

2. 三条超分路线怎么选：EDVR、SRCNN、FSRCNN 的定位与参数差异

2.1 为什么不是随便挑一个模型跑通就行

很多人拿到这类资源，第一反应是「哪个模型效果好用哪个」。但实际部署时，选型取决于你的输入是单帧图像还是视频序列、显存有多大、要不要实时预览。SRCNN 是超分领域的开山之作，结构极简，三层卷积，适合做基线验证和教学演示；FSRCNN 在 SRCNN 基础上把低分辨率特征提取前置，用反卷积做上采样，速度明显快一截，适合对推理耗时敏感的场景；EDVR 则是视频超分里的重量级选手，靠可变形卷积做帧间对齐，再叠加时空注意力，效果最好但显存和算力要求也最高。这套资源把三者放在一起，本质上是让你在同一套数据流里对比「轻量基线 → 加速改进 → 视频专用」的递进关系。

从参数角度看，SRCNN 和 FSRCNN 通常按固定放大倍数（比如 x2、x3、x4）训练和推理，输入是单帧；EDVR 需要连续多帧作为输入，默认 5 帧一组，对齐和融合都在这个窗口内完成。你在 Tkinter 界面上切换模型时，背后其实是在切换不同的预处理逻辑：单帧模型直接读当前帧，EDVR 要维护一个帧队列。这个差异如果没搞清楚，最容易出现的问题就是「用 EDVR 跑单张图报错」或者「用 SRCNN 跑视频时帧间闪烁严重」。

2.2 模型加载与推理入口的代码拆解

下面这段是典型的模型调度逻辑，我按资源里的组织方式还原了一个可运行的版本，重点看模型分支和输入张量的构造差异：

import torch
import cv2
import numpy as np
from basicsr.archs.edvr_arch import EDVR
from basicsr.archs.srcnn_arch import SRCNN
from basicsr.archs.fsrcnn_arch import FSRCNN

def build_model(model_name, scale=4, device='cuda'):
    """按名称构建对应超分模型，返回 eval 模式下的模型实例"""
    if model_name == 'edvr':
        # EDVR 需要指定帧数、对齐模块和融合模块
        model = EDVR(
            num_in_ch=3, num_out_ch=3, num_feat=64,
            num_frame=5, deformable_groups=8,
            num_extract_block=5, num_reconstruct_block=10
        )
    elif model_name == 'srcnn':
        model = SRCNN(num_in_ch=3, num_out_ch=3, num_feat=64)
    elif model_name == 'fsrcnn':
        model = FSRCNN(scale=scale, num_in_ch=3, num_out_ch=3,
                       d=56, s=12, m=4)
    else:
        raise ValueError(f'不支持的模型: {model_name}')
    model.eval()
    return model.to(device)

def inference_single_frame(model, frame, device='cuda'):
    """单帧推理，适配 SRCNN / FSRCNN"""
    img = frame.astype(np.float32) / 255.0
    img = torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0).to(device)
    with torch.no_grad():
        out = model(img)
    out = out.squeeze(0).permute(1, 2, 0).cpu().numpy()
    return (out * 255.0).clip(0, 255).astype(np.uint8)

def inference_video_clip(model, frames, device='cuda'):
    """EDVR 多帧推理，frames 是长度为 5 的帧列表"""
    clip = np.stack(frames, axis=0).astype(np.float32) / 255.0
    clip = torch.from_numpy(clip).permute(3, 0, 1, 2).unsqueeze(0).to(device)
    with torch.no_grad():
        out = model(clip)
    out = out.squeeze(0).permute(1, 2, 0).cpu().numpy()
    return (out * 255.0).clip(0, 255).astype(np.uint8)

逻辑说明： build_model 里 EDVR 的 num_frame=5 决定了它必须吃 5 帧连续输入， deformable_groups=8 是对齐模块的分组数，显存不够时可以降到 4 或 2。FSRCNN 的 d=56 是特征维度， s=12 是收缩层通道数， m=4 是映射层数量，这三个参数直接决定模型大小和速度。 inference_single_frame 和 inference_video_clip 的区别在于张量维度：单帧是 (1, C, H, W) ，视频片段是 (1, T, C, H, W) ，EDVR 内部会对 T 维度做对齐和融合。如果你把单帧图硬塞给 EDVR，它会在对齐模块里因为帧数不匹配直接报维度错误。

参数调整建议：显存 8G 以下跑 EDVR 时，把 num_frame 降到 3， num_feat 从 64 降到 32，基本能压到 6G 以内。FSRCNN 的 d 参数对速度影响最大，从 56 降到 32，推理耗时大概能少三分之一，但 PSNR 会掉 0.2 左右，这个取舍看你的场景。

2.3 Tkinter 界面与推理线程的衔接方式

Tkinter 本身是单线程事件循环，如果把推理直接写在按钮回调里，界面会卡死直到这一帧或这段视频处理完。资源里常见的做法是开一个独立线程跑推理，主线程只负责刷新预览。下面是一个可抄的线程封装：

import threading
import tkinter as tk
from tkinter import filedialog
from PIL import Image, ImageTk

class SRApp:
    def __init__(self, root):
        self.root = root
        self.model = None
        self.device = 'cuda'
        self.btn_load = tk.Button(root, text='加载模型', command=self.load_model)
        self.btn_load.pack()
        self.btn_run = tk.Button(root, text='开始超分', command=self.run_async)
        self.btn_run.pack()
        self.canvas = tk.Label(root)
        self.canvas.pack()

    def load_model(self):
        # 这里按界面选择切换模型名称
        self.model = build_model('fsrcnn', scale=4, device=self.device)

    def run_async(self):
        # 把耗时推理丢到子线程，避免阻塞 Tkinter 主循环
        t = threading.Thread(target=self.process_video)
        t.start()

    def process_video(self):
        cap = cv2.VideoCapture('calendar.avi')
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            out = inference_single_frame(self.model, frame, self.device)
            # 子线程里更新界面必须走 after，不能直接操作控件
            self.root.after(0, self.update_preview, out)
        cap.release()

    def update_preview(self, frame):
        img = Image.fromarray(cv2.cvtColor(frame, cv2.COLOR_BGR2RGB))
        imgtk = ImageTk.PhotoImage(image=img)
        self.canvas.imgtk = imgtk
        self.canvas.configure(image=imgtk)

逻辑说明： run_async 里创建线程后立刻返回，Tkinter 主循环继续响应其他事件。子线程里读视频帧、调模型推理，但更新界面不能直接调 self.canvas.configure ，必须用 self.root.after(0, ...) 把更新操作丢回主线程。这是 Tkinter 线程安全的基本规则，踩过一次就记住了。 update_preview 里用 PIL 做 BGR 到 RGB 的转换，再转成 PhotoImage ，注意 imgtk 要挂在控件上保持引用，否则会被垃圾回收导致界面空白。

3. 从 avi 到超分输出：完整数据流与 BasicSR 配置对接

3.1 视频解码、帧队列与批量推理的工程化处理

资源里给的 calendar.avi 、 foliage.avi 、 walk.avi 、 city.avi 都是标准测试序列，分辨率不高，适合快速验证。但实际跑的时候，你不能一帧一帧喂给 EDVR，得维护一个长度为 5 的滑动窗口。下面这段是帧队列的典型实现：

from collections import deque

def process_video_edvr(model, video_path, output_path, device='cuda'):
    """EDVR 视频超分主流程，维护 5 帧滑动窗口"""
    cap = cv2.VideoCapture(video_path)
    fps = cap.get(cv2.CAP_PROP_FPS)
    w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) * 4
    h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) * 4
    fourcc = cv2.VideoWriter_fourcc(*'XVID')
    out_writer = cv2.VideoWriter(output_path, fourcc, fps, (w, h))

    frame_buffer = deque(maxlen=5)
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        frame_buffer.append(frame)
        if len(frame_buffer) < 5:
            continue
        # 窗口满了才做一次推理，输出中间帧的超分结果
        out_frame = inference_video_clip(model, list(frame_buffer), device)
        out_writer.write(out_frame)

    cap.release()
    out_writer.release()

逻辑说明： deque(maxlen=5) 自动维护滑动窗口，前 4 帧只入队不推理，第 5 帧开始每次推理输出一帧。这里有个细节：EDVR 输出的是中间帧的超分结果，所以窗口滑动步长是 1，输出帧率跟输入一致。 cv2.VideoWriter 的 fourcc 用 XVID 兼容性最好，输出分辨率是输入的四倍（对应 scale=4）。如果你用 FSRCNN 跑视频，就不需要帧队列，直接逐帧推理逐帧写，代码更简单，但帧间一致性会差一些，快速运动场景可能出现闪烁。

3.2 BasicSR 配置文件的关键字段与覆盖方式

BasicSR 的推理通常走 YAML 配置，但在这套资源里，模型构建和权重加载是手动接的。如果你要改成标准 BasicSR 流程，核心字段就这几个：

字段	含义	典型值	注意点
num_in_ch	输入通道数	3	RGB 图像固定为 3
num_out_ch	输出通道数	3	超分不改变通道数
num_feat	基础特征维度	64	降到 32 可省显存
num_frame	EDVR 输入帧数	5	必须与推理时窗口一致
deformable_groups	可变形卷积分组	8	显存不足时降为 4
scale	放大倍数	4	需与训练时一致

加载权重时，常见做法是用 torch.load 读 checkpoint，然后 model.load_state_dict(state_dict, strict=False) 。 strict=False 是为了容忍 EDVR 里某些辅助模块的键名差异，但你要盯着日志看哪些键没匹配上，如果主干卷积层没加载成功，输出会是噪声。

3.3 输出视频的编码参数与质量校验

超分输出写回 avi 时，编码器选择直接影响文件大小和画质。 XVID 是 MPEG-4 Part 2 编码，兼容性好但压缩率一般；如果你环境里有 FFV1 或 H264 ，可以换。校验环节我一般抽三帧做 PSNR 对比：

from skimage.metrics import peak_signal_noise_ratio as psnr

def validate_frame(sr_frame, hr_frame):
    """对比超分结果与高分辨率参考帧"""
    score = psnr(hr_frame, sr_frame, data_range=255)
    print(f'PSNR: {score:.2f} dB')
    return score

逻辑说明： data_range=255 对应 8 位图像。PSNR 低于 28dB 基本说明模型没加载对或者预处理有问题。注意超分输出和参考帧必须严格对齐，如果参考帧是原始高分辨率视频，要确认帧号一一对应，否则 PSNR 没有意义。

4. 避坑与排查：跑通这套资源最容易翻车的五个地方

4.1 现象：EDVR 推理报维度错误 → 原因：帧数不匹配 → 解决：检查窗口长度

EDVR 的 num_frame 在构建模型时就固定了，推理时传入的帧数必须完全一致。常见错误是窗口还没满 5 帧就调了推理，或者视频末尾剩余帧数不足。解决方式是在 process_video_edvr 里加判断，不足 5 帧时用最后一帧填充或者直接跳过。我一般会在窗口满之前用 continue 跳过，末尾不足时复制最后一帧补齐。

4.2 现象：Tkinter 界面点按钮后无响应 → 原因：推理阻塞主线程 → 解决：强制走子线程 + after 回主线程

这个坑几乎每个用 Tkinter 做推理界面的人都会踩。按钮回调里直接调模型推理，主循环被占住，界面假死。解决方式就是前面代码里的 threading.Thread 加 root.after 。注意子线程里不要碰任何 Tkinter 控件，所有界面更新都通过 after 排队。

4.3 现象：输出视频花屏或颜色异常 → 原因：BGR/RGB 通道顺序搞反 → 解决：统一在推理前转 RGB，写回前转 BGR

OpenCV 读进来是 BGR，模型训练时用的是 RGB。如果推理前没转，输出颜色会偏。写回 VideoWriter 时又要转回 BGR。我习惯在 inference_single_frame 入口做 cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) ，出口做反向转换，这样模型内部始终是 RGB。

4.4 现象：显存溢出 → 原因：EDVR 的 num_feat 和 num_frame 太大 → 解决：降参 + 分块推理

8G 显存跑默认 EDVR 配置基本会 OOM。先把 num_feat 从 64 降到 32， num_frame 从 5 降到 3， deformable_groups 从 8 降到 4。如果还不够，把输入帧裁剪成 256x256 的块，分块推理再拼接，边缘重叠 16 像素避免接缝。

4.5 现象：FSRCNN 输出模糊 → 原因：权重没加载或 scale 不匹配 → 解决：核对 checkpoint 的 scale 与模型构建参数

FSRCNN 的 scale 参数决定反卷积层的步长，如果 checkpoint 是 x4 训练的，你构建模型时用了 x2，权重形状对不上， load_state_dict 会报错或者静默跳过。用 strict=True 加载，报错就说明参数不匹配。另外确认权重文件确实加载进去了，打印一下 model.conv1.weight.mean() 看是不是随机初始化的值。

5. 进阶技巧：用 MATLAB 做结果对比与批量评估的轻量方案

5.1 为什么还要拉 MATLAB 进来

Python 侧负责推理，MATLAB 侧做评估和可视化，这是这套资源里比较务实的分工。MATLAB 的 VideoReader 和 implay 在快速抽帧对比上比 Python 顺手，尤其是你要批量算 PSNR、SSIM 并画曲线的时候。下面这段是 MATLAB 读取超分输出和参考视频、逐帧算 PSNR 的脚本：

% 读取超分输出与参考视频，逐帧计算 PSNR
sr_video = VideoReader('calendar_out.avi');
hr_video = VideoReader('calendar_hr.avi');
psnr_list = [];

while hasFrame(sr_video) && hasFrame(hr_video)
    sr_frame = readFrame(sr_video);
    hr_frame = readFrame(hr_video);
    % 确保尺寸一致，不一致时用 imresize 对齐
    if ~isequal(size(sr_frame), size(hr_frame))
        hr_frame = imresize(hr_frame, [size(sr_frame,1), size(sr_frame,2)]);
    end
    psnr_val = psnr(sr_frame, hr_frame);
    psnr_list = [psnr_list, psnr_val];
end

fprintf('平均 PSNR: %.2f dB\n', mean(psnr_list));
plot(psnr_list);
xlabel('帧号'); ylabel('PSNR (dB)');
title('超分结果逐帧 PSNR');

逻辑说明： VideoReader 逐帧读取， psnr 函数要求两帧尺寸一致，不一致时用 imresize 对齐。 psnr_list 存每帧得分，最后画曲线看波动。如果某些帧 PSNR 骤降，通常是运动剧烈导致对齐失败，EDVR 在这种情况下也会掉点。MATLAB 的 implay 可以同时播放两个视频做肉眼对比，比 Python 里开两个窗口方便。

5.2 批量评估多个测试序列的脚本组织

资源里给了 calendar 、 foliage 、 walk 、 city 四个序列，我一般写个循环批量跑：

sequences = {'calendar', 'foliage', 'walk', 'city'};
results = struct();

for i = 1:length(sequences)
    name = sequences{i};
    sr_path = sprintf('%s_out.avi', name);
    hr_path = sprintf('%s_hr.avi', name);
    if ~isfile(sr_path) || ~isfile(hr_path)
        fprintf('跳过 %s：文件缺失\n', name);
        continue;
    end
    sr_v = VideoReader(sr_path);
    hr_v = VideoReader(hr_path);
    scores = [];
    while hasFrame(sr_v) && hasFrame(hr_v)
        s = readFrame(sr_v);
        h = readFrame(hr_v);
        if ~isequal(size(s), size(h))
            h = imresize(h, [size(s,1), size(s,2)]);
        end
        scores(end+1) = psnr(s, h);
    end
    results.(name) = mean(scores);
    fprintf('%s 平均 PSNR: %.2f dB\n', name, results.(name));
end

逻辑说明：用结构体 results 存每个序列的平均 PSNR，方便后续排序或导出。 isfile 做存在性检查，缺文件就跳过，不中断整个批量流程。这个脚本跑完，你基本能判断哪个序列对当前模型最不友好， walk 这种运动剧烈的通常得分最低。

5.3 一个我踩过的坑和后来的习惯

最早跑这套资源时，我直接把 Python 输出的 avi 丢给 MATLAB 算 PSNR，结果数值低得离谱。排查了半天才发现，Python 侧 VideoWriter 写出来的是 BGR 顺序，MATLAB readFrame 读进来按 RGB 解释，通道反了，PSNR 自然崩。后来我养成一个习惯：任何跨语言、跨工具的视频交接，先抽一帧存成 PNG，两边分别读进来对比像素值，确认通道顺序和数值范围一致，再跑批量评估。这个检查花不了一分钟，但能省掉几个小时的玄学排查。希望帮到你。

本文还有配套的精品资源，点击获取