图像超分算法实战：从插值到深度学习的全面对比与Python实现

1. 先弄明白：超分到底在解决什么问题

图像超分辨率（Super-Resolution，简称超分）这几年在安防监控、医疗影像、老照片修复、手机摄影这些场景里几乎成了标配技术。简单说，超分就是输入一张低分辨率图，输出一张高清图，而且不是简单放大，是要恢复出真实存在但被采样过程丢失的高频细节。

我第一次认真接触超分算法是在做老照片修复项目的时候，当时手上有一批扫描出来的老照片，分辨率只有 720x540，放大到 2K 屏幕上全是马赛克和锯齿。最先想到的是用 Photoshop 里的“图像大小”直接拉，但效果一言难尽，边缘全是台阶。后来才一点点从插值方法看到深度学习方法，发现自己之前对“放大图片”这件事的理解太浅了。

从技术层面看，超分问题的标准建模是这样的：假设原始高清图是 (x)，经过一个退化过程得到低分辨率图 (y)，通常写成 (y = D(x) + n)，其中 (D) 是下采样操作（可能带模糊），(n) 是噪声。超分的目标就是从 (y) 反推出尽可能接近 (x) 的结果。问题在于，这个反推是一个典型的病态问题：一张低分辨率图可以对应无数张可能的高清图，比如一个 2x2 的像素块放大到 4x4，中间缺失的 12 个像素点理论上可以是任意值。

正因为解不唯一，不同超分方法的本质差别就在于如何给这个“不唯一”加上约束。插值方法加的约束是“局部平滑假设”——挨得近的像素颜色应该接近；深度学习方法加的约束则是“从数据中学习到的自然图像先验”，用成对的低清/高清图训练一个网络，让网络记住真实世界里图像细节长什么样。

这篇文章我会从最近邻插值、双线性插值、双三次插值讲到 SRCNN、ESPCN 这类深度学习方法，每一段都配 Python 代码，最后用同一张测试图做横向对比。适合刚入门图像处理或者准备深度学习课程大作业的朋友，看完你就能自己动手跑一遍完整的超分流程。

2. 传统插值方法：从最近邻到双三次

2.1 最近邻：最粗暴也最容易理解

最近邻插值的思路没有任何花哨：目标图中的每个像素点，坐标除以放大倍数，映射回原图，然后取距离最近的那个原图像素值。它假设相邻像素的值足够接近，所以直接用原样复制。

它的 Python 实现很直白：

import numpy as np def nearest_interp(img, scale): """ img: H x W x C, dtype=uint8 scale: 放大倍数 """ h, w = img.shape[:2] new_h, new_w = int(h * scale), int(w * scale) out = np.zeros((new_h, new_w) + img.shape[2:], dtype=img.dtype) for i in range(new_h): for j in range(new_w): src_y = min(int(i / scale), h - 1) src_x = min(int(j / scale), w - 1) out[i, j] = img[src_y, src_x] return out

这个算法的问题非常明显：放大后会产生严重的块状锯齿，尤其是斜线边缘。你想象一张图片是马赛克拼成的，每个马赛克被等比例放大成一个方块，就是这个效果。虽然计算速度几乎为零成本，但实际应用里基本只用来做快速预览，或者用作某些算法的初始值。

2.2 双线性插值：一阶近似的进阶

双线性插值比最近邻多走了一步：它考虑了周围 4 个像素的影响，具体做法是在 x 方向和 y 方向各做一次线性插值。数学表达式可以写成：

[ f(x,y) \approx (1-dx)(1-dy) f(x_0,y_0) + dx(1-dy) f(x_1,y_0) + (1-dx)dy f(x_0,y_1) + dxdy f(x_1,y_1) ]

其中 ((x_0,y_0)) 和 ((x_1,y_1)) 是目标点在原图中对应的相邻网格点，(dx, dy) 是小数部分的偏移量。这个式子本质上就是在做两个方向的拉格朗日一阶插值。

对应代码：

def bilinear_interp(img, scale): """ img: H x W x C, dtype=uint8 """ h, w = img.shape[:2] new_h, new_w = int(h * scale), int(w * scale) out = np.zeros((new_h, new_w) + img.shape[2:], dtype=np.float32) for i in range(new_h): for j in range(new_w): x = j / scale y = i / scale x0 = int(np.floor(x)) y0 = int(np.floor(y)) x1 = min(x0 + 1, w - 1) y1 = min(y0 + 1, h - 1) dx = x - x0 dy = y - y0 out[i, j] = ( (1 - dx) * (1 - dy) * img[y0, x0] + dx * (1 - dy) * img[y0, x1] + (1 - dx) * dy * img[y1, x0] + dx * dy * img[y1, x1] ) return out.astype(np.uint8)

双线性插值比最近邻平滑得多，不会出明显的像素块，但问题是它只有一阶连续性，放大到一定程度后图像会显得偏软、发糊，高频细节（比如头发丝、布纹）全被抹平了。原因也很简单：线性模型只能拟合平坦区域，对边缘处的非线性变化无能为力。

2.3 双三次插值：工程中最常用的插值天花板

双三次插值（Bicubic）是传统插值方法里工程应用最多的一个，OpenCV 里cv2.resize的INTER_CUBIC就是它，Photoshop 的“平滑渐变”放大也默认用它。

它不再只看周围 4 个像素，而是取目标点周围 4x4 共 16 个像素，然后用一个三次多项式核函数计算权重。这个核函数虽然是近似形式，但你可以把它理解成用三次多项式去拟合已知的离散像素点，和拉格朗日插值的思路完全一致，只是阶数更高，连续性更好。

核函数的常见形式是：

[ W(d) = \begin{cases} (a+2)|d|^3 - (a+3)|d|^2 + 1, & |d| \le 1 \ a|d|^3 - 5a|d|^2 + 8a|d| - 4a, & 1 < |d| < 2 \ 0, & |d| \ge 2 \end{cases} ]

其中参数 (a) 通常取 -0.5 或 -0.75，控制边缘增强的强度。OpenCV 默认的INTER_CUBIC用 (a=-0.75)，看起来边缘更锐利一些。

如果你不想自己写这个卷积核，直接用 OpenCV 即可：

import cv2 def bicubic_interp(img, scale): return cv2.resize(img, (int(img.shape[1] * scale), int(img.shape[0] * scale)), interpolation=cv2.INTER_CUBIC)

双三次插值的视觉效果远好于前面两种，边缘相对清晰，灰度过渡自然。但它的短板也很明显：它本质上仍然是一个“公式”，没有理解图像内容。遇到复杂纹理、周期性图案（比如百叶窗、编织物），它会产生振铃效应，就是物体边缘附近出现明暗交替的“鬼影”条纹。

2.4 插值方法的问题在哪

插值类方法之所以无法真正“超分”，归根结底是因为它们在做一件自欺欺人的事：低分辨率图里没记录的高频信息，插值算不出来。

举个非常直观的例子：如果原图里有一段频率很高的细条纹，采样成低分辨率图后，这段条纹可能已经被混叠成了大片灰蒙蒙的区域。插值算法看到的就是一片灰色，它没有任何依据能“猜”出这里本来是明暗交替的细条纹，所以只能输出平滑的过渡。

要真正恢复出缺失的细节，必须借助外部知识。深度学习的思路就是从海量自然图像里学习“低清图块和高清图块之间的映射关系”，相当于给算法装了一个庞大的图像先验知识库。这就是为什么当深度学习进入超分领域后，效果一下子超越了所有传统插值方法。

3. 深度学习超分：从SRCNN到亚像素卷积

3.1 SRCNN：把超分当成端到端的回归

2014 年汤晓鸥团队的 SRCNN 是深度学习超分的开山之作，结构简单到让人怀疑它的效果：一个三层的普通卷积网络，输入是低分辨率图（先双三次插值放大到目标尺寸），经过特征提取、非线性映射、图像重建三个步骤，直接输出高清图。

SRCNN 的核心思想可以拆成三块看：

• 第一层卷积：把输入图像映射成一个高维特征空间，相当于提取图像块级别的局部特征。
• 第二层卷积：在这个特征空间里做非线性变换，把低分辨率特征映射到高分辨率特征。这一步是“涨知识”的关键，网络在这里学到了低清到高清的对应关系。
• 第三层卷积：把高分辨率特征重新投影成彩色图像，完成重建。

训练的时候用的是均方误差损失（MSE），目标就是让网络输出的高清图和真实高清图的像素差最小。数据集用 VOC、ImageNet 这类自然图像，先人工下采样成低分辨率图，再和原始高清图组成训练对。

用 PyTorch 实现一个简化版 SRCNN 非常容易：

import torch import torch.nn as nn class SRCNN(nn.Module): def __init__(self, num_channels=3): super(SRCNN, self).__init__() self.conv1 = nn.Conv2d(num_channels, 64, kernel_size=9, padding=4) self.conv2 = nn.Conv2d(64, 32, kernel_size=1, padding=0) self.conv3 = nn.Conv2d(32, num_channels, kernel_size=5, padding=2) self.relu = nn.ReLU(inplace=True) def forward(self, x): x = self.relu(self.conv1(x)) x = self.relu(self.conv2(x)) x = self.conv3(x) return x

当时这个网络在 Set5 测试集上，3 倍超分的 PSNR 达到了 32.75dB，大幅超过双三次插值的 30.39dB。放在今天看这个数字不算惊艳，但在当年已经是质变——深度学习第一次证明让机器“脑补”细节是可行的。

3.2 ESPCN：亚像素卷积的效率革命

SRCNN 有一个明显的性能问题：它要求输入先被双三次插值放大到目标尺寸，再进网络。这意味着卷积操作全部在高分辨率空间里计算，计算量大，而且插值放大本身就引入了一部分不真实的信息。

2016 年的 ESPCN 换了个思路：低分辨率图直接进网络，到最后一层才放大。它用了一个叫亚像素卷积（PixelShuffle）的操作，把特征图的通道维度重新排列成空间维度。举个例子，如果要做 3 倍放大，最后一层输出 9 个通道的特征图，然后按特定顺序重排列成宽高各放大 3 倍的图像。

亚像素卷积的原理，本质上就是让网络自己学一组上采样滤波器，而不是用固定的插值核。它的优势有两个：

• 计算量大幅降低，因为前面的卷积全在低分辨率空间做。
• 上采样核是从数据里学出来的，重建质量更高。

PyTorch 里实现 ESPCN 的最后一层特别简洁：

class ESPCN(nn.Module): def __init__(self, num_channels=3, upscale_factor=3): super(ESPCN, self).__init__() self.conv1 = nn.Conv2d(num_channels, 64, kernel_size=5, padding=2) self.conv2 = nn.Conv2d(64, 64, kernel_size=3, padding=1) self.conv3 = nn.Conv2d(64, 32, kernel_size=3, padding=1) self.conv4 = nn.Conv2d(32, num_channels * (upscale_factor ** 2), kernel_size=3, padding=1) self.pixel_shuffle = nn.PixelShuffle(upscale_factor) self.relu = nn.ReLU(inplace=True) def forward(self, x): x = self.relu(self.conv1(x)) x = self.relu(self.conv2(x)) x = self.relu(self.conv3(x)) x = self.pixel_shuffle(self.conv4(x)) return x

这个思路后来演变成了几乎所有主流超分模型的基础结构，包括 SRGAN、EDSR、ESRT，底层都是先低分辨率空间提特征，最后再上采样。

3.3 训练细节决定了上限

很多初学者跑深度超分模型发现效果不如论文，问题往往不在网络结构，而在训练细节。

数据准备上，不要用整张图直接训练。因为一张 1080p 的图进网络会撑爆显存，而且整图的纹理分布可能很单一，模型学不到多样化特征。正确做法是从高清图上随机裁剪出一堆小图块（比如 64x64 或 96x96），再下采样成对应小尺寸的低分辨率图，组成训练对。一个 epoch 里模型能看到几十万个小图块，学到的东西才足够丰富。

数据增强也很关键。除了常规的水平翻转和旋转，随机缩放对超分模型特别有用。因为实际应用里低分辨率图的退化尺度千差万别，训练时让模型见识不同倍数的下采样，它才能有泛化能力。

还有几个坑是论文里很少写的：

• 归一化必须做。输入要除以 255 变成 0 到 1 的浮点数再进网络，否则深层网络的梯度会爆炸。我见过有人直接拿 uint8 训练，loss 曲线当场表演起飞。
• 学习率要用阶梯下降。超分任务不同于分类，MSE 类的 loss 收敛很慢，一开始用 1e-4，每 20 个 epoch 降一半，通常 100 个 epoch 左右能看出明显效果。
• BatchNorm 在超分里不是必需品。超分是逐像素回归任务，bn 层的 batch 统计量会抹掉很多纹理细节。SRCNN、EDSR 这些经典模型内部都不带 BN。

前一阵帮人看一道深度学习课程大作业，题目就是让从零实现 SRCNN 并在小数据集上训练。那位同学在训练时用了 BN 层，结果是验证集 PSNR 卡在 29dB 上不去，去掉 BN 之后很快就到了 31dB。这个细节很典型，值得记下来。

4. 实战对比：同一张图，插值和深度学习谁更强

4.1 环境准备与数据准备

动手之前先准备环境，我用的是 Python 3.10，依赖库如下：

pip install numpy opencv-python scikit-image torch torchvision

测试图片我建议别用什么风景大片，直接选一张有大量规则纹理和清晰边缘的图，比如带百叶窗的建筑、有栅栏的人像、布料特写。这种图最能放大各算法之间的差异。我这里用的是 Set5 数据集里的一张经典测试图 baby，尺寸 512x512，需要注意的是超分测试图的命名可能不同，实际跑的时候换成你手头的图即可。

超分实验要做控制变量，所以低分辨率图必须来自同一张高清图的人工退化，而不是随便找一张天然的低清图。退化方式用高斯模糊加双三次下采样，这一步在 sklearn 风格的对比里尤其重要，否则你测出来的 PSNR 根本没法说明问题。

准备低分辨率图的代码：

import cv2 import numpy as np img = cv2.imread("baby.png") # H x W x C, BGR h, w = img.shape[:2] scale = 3 # 先做轻微高斯模糊模拟光学退化 blurred = cv2.GaussianBlur(img, (5, 5), 1.0) # 下采样 lr = cv2.resize(blurred, (w // scale, h // scale), interpolation=cv2.INTER_CUBIC) # 保存低分辨率图供后续对比用 cv2.imwrite("baby_lr.png", lr)

这里有个细节：如果你直接用cv2.resize(img, (w // scale, h // scale))下采样，得到的结果再做三次放大，最终 PSNR 会比使用高斯模糊的版本高很多，因为普通下采样已经包含了某种程度的抗锯齿处理。测试时无法保证实际场景符合这个理想退化模型，所以我更推荐带模糊的版本，更接近真实情况。

4.2 用 Python 实现三种插值

三种插值方法直接用上一节写好的函数，或者用 OpenCV 统一跑：

# 最近邻 lr_nn = cv2.resize(lr, (w, h), interpolation=cv2.INTER_NEAREST) # 双线性 lr_bilinear = cv2.resize(lr, (w, h), interpolation=cv2.INTER_LINEAR) # 双三次 lr_bicubic = cv2.resize(lr, (w, h), interpolation=cv2.INTER_CUBIC)

这里有个容易踩的坑：OpenCV 的resize在高倍数放大时，INTER_CUBIC的效果会比低倍数更好。这是因为双三次核的支撑域（4x4 邻域）相对更大，能利用更多信息。如果是 2 倍放大，双线性和双三次差距不大；一旦到 4 倍以上，双三次的优势就很明显了。所以工程上如果只是简单放大 2 倍，优先用双线性，速度更快，效果也够用。

4.3 用 PyTorch 跑一个深度超分模型

这里我不推荐你在本地从零训练一个完整模型，太耗时，而且没有 GPU 的情况下一个 epoch 可能要跑十几分钟。更实际的做法是：用小数据集跑少量 epoch 看趋势，或者加载网上的预训练权重。为了演示流程，我给出一个完整的训练-评估脚本，你可以在自己的环境里跑。

先写一个标准的数据加载器：

import torch from torch.utils.data import Dataset, DataLoader from torchvision import transforms class SRDataset(Dataset): def __init__(self, hr_images, scale=3, patch_size=96): self.hr_images = hr_images self.scale = scale self.patch_size = patch_size def __len__(self): return len(self.hr_images) * 100 # 每个epoch随机裁剪100次 def __getitem__(self, idx): hr = self.hr_images[idx % len(self.hr_images)] hr = random_crop(hr, self.patch_size) # 下采样得到LR h, w = hr.shape[:2] lr = cv2.resize(hr, (w // self.scale, h // self.scale), interpolation=cv2.INTER_CUBIC) # 转为tensor，归一化到0-1 hr_tensor = torch.from_numpy(hr.transpose(2, 0, 1)).float() / 255.0 lr_tensor = torch.from_numpy(lr.transpose(2, 0, 1)).float() / 255.0 # 用双三次插值把LR放大到HR尺寸，作为SRCNN的输入 lr_up = cv2.resize(lr, (w, h), interpolation=cv2.INTER_CUBIC) lr_up_tensor = torch.from_numpy(lr_up.transpose(2, 0, 1)).float() / 255.0 return lr_up_tensor, hr_tensor

训练循环核心部分：

model = SRCNN() optimizer = torch.optim.Adam(model.parameters(), lr=1e-4) criterion = torch.nn.MSELoss() scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5) for epoch in range(100): model.train() total_loss = 0 for lr_up, hr in dataloader: optimizer.zero_grad() pred = model(lr_up) loss = criterion(pred, hr) loss.backward() optimizer.step() total_loss += loss.item() scheduler.step() print(f"Epoch {epoch+1}, Loss: {total_loss / len(dataloader):.6f}")

如果你只是想做效果对比，懒得训练，也可以直接用我自己训练好的简版模型权重（大约 30MB，可以放到网盘）。不过权重的跨场景泛化能力有限，训练数据多样性不够时，效果提升会打折扣。真正想复现论文效果，还是得在 DIV2K 这类数据集上好好训练一轮。

4.4 量化指标对比：PSNR 和 SSIM 怎么看

对比不能只看“看着顺不顺眼”，需要量化指标。超分领域最常用的两个指标是 PSNR（峰值信噪比）和 SSIM（结构相似性）。

我自己写了一个简单的计算函数：

import math from skimage.metrics import structural_similarity as ssim def psnr(img1, img2): img1 = img1.astype(np.float64) img2 = img2.astype(np.float64) mse = np.mean((img1 - img2) ** 2) if mse == 0: return float('inf') return 20 * math.log10(255.0 / math.sqrt(mse)) # 注意SSIM通常需要在灰度图上计算，或者逐通道计算再取平均 def ssim_color(img1, img2): img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY) img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2GRAY) return ssim(img1, img2)

用同一张 baby 测试图，在 3 倍超分设置下，我实测的一组结果如下：

从表格能看出，深度学习方法的 PSNR 比双三次插值高出 2 到 3 个 dB。这个差距是什么概念？PSNR 每提高 1dB，平均像素误差大约减少 10% 到 20%，视觉上就是纹理从“一团糊”变成“能看出轮廓”再到“接近原图”的差别。

但只看数字还不够，视觉体验才是最终标准。建议把几种结果并排放大到 200% 看细节，特别是边缘和纹理区域。插值方法的边缘会有明显的模糊过渡，而深度学习方法恢复出的边缘更锐利，甚至能看出清晰的头发丝和布料纹理。当然，深度学习方法也不是万能的，它会把学会的“纹理先验”强行套上去，如果训练集里没见过类似纹理，也可能产生幻觉细节。

5. 实操中我踩过的坑（问题排查实录）

5.1 评估指标别只看 PSNR

PSNR 是一个严格的像素级指标，但它的缺陷也很突出：它对结构信息不敏感。换句话说，一张被高斯模糊过的图和一张有轻微位移的图，PSNR 可能差不多，但视觉体验完全不同。SSIM 考虑了亮度、对比度、结构三个维度，稍微好一些。更严格的评估还要看感知指标（比如 LPIPS），不过日常做对比实验，PSNR+SSIM 已经够用了。

更大的坑是评估时的边界处理。如果你的网络模型里有卷积且没有 padding 设置合理，输出图像会比输入小一圈。对比的时候如果直接拿整图和原图算 PSNR，边界区域的误差会严重拉低分数。正确做法是计算 PSNR 时把边缘裁掉，比如每边裁掉 6 个像素，或者用 padding 保证尺寸严格一致。

5.2 下采样方式和训练数据对齐问题

这是被人问得最多的一个问题：为什么我复现的 SRCNN 效果不如论文？十有八九是下采样方式不一致。

超分训练时用的退化模型是固定的，比如论文里用的是 MATLAB 的imresize的bicubic模式，但 MATLAB 的双三次实现和 OpenCV 的INTER_CUBIC在滤波核细节上有细微差别。你如果用 OpenCV 下采样训练，又用 MATLAB 下采样测试，效果自然崩。解决办法是训练和测试流程必须统一，可以写一个共享的退化函数，所有模块都调用它。

另外，很多训练代码里会把 YCbCr 色彩空间的 Y 通道单独拿来训练，因为人眼对亮度变化最敏感，彩色通道的细节可以用简单插值补齐。这种做法能显著降低计算量，但如果模型只在 Y 通道上训练，测试时千万不要直接把 RGB 三个通道都送进模型，否则输出会有严重的色偏。

5.3 归一化、颜色空间与边界处理

超分模型的输入输出都是图像，归一化方式比分类模型更讲究。推荐的流程是：先把图像从 uint8 转为 float，再除以 255 得到 0 到 1 区间，进网络。训练结束后的输出要乘回 255，再转 uint8。

如果你打算用 YCbCr 空间，需要留意的是 OpenCV 里的颜色转换是 BGR 顺序，cv2.cvtColor(img, cv2.COLOR_BGR2YCrCb)出来的第一个通道是 Y。而 PyTorch 里的图像 tensor 转成CHW格式时，通道顺序默认是 RGB。如果不对齐，训练时模型学的颜色映射就全乱了。我一开始做实验就栽在这里，模型训练了 30 轮，输出图发绿，检查半天发现是通道顺序问题。

边界处理上，模型输入尺寸要是下采样倍数的整数倍，不然最后上采样后尺寸对不上。比如 3 倍超分，输入宽度必须是 3 的倍数，用math.floor(h / scale) * scale对输入做裁剪，避免生成尺寸错位的输出。

5.4 深度学习训练的一些细节

训练超分模型时，我踩过的坑一个接一个，挑几个印象深刻的记录下来。

首先是BatchNorm 问题。超分任务对每个像素求损失，BatchNorm 会引入 batch 内的统计信息，破坏像素独立性。很多经典超分模型里没有 BN 层，这不是偶然。如果你从分类任务转过来习惯了每层都加 BN，在超分里一定要记得去掉。

其次是学习率和优化器选择。超分模型最常用 Adam，因为它对初始学习率没那么敏感。但 Adam 在训练后期容易陷入局部极小值，这时候切到 SGD+momentum 有时候能再涨 0.2dB。我习惯的做法是：前 50 个 epoch 用 Adam，后面切换成 SGD，学习率固定在 1e-5，效果不错。

然后是训练数据的多样性。我之前用一堆人像照片训练，模型在风景图上测试，结果 PSNR 只比双三次高一点点。因为训练集里没有足够多的高频纹理（树叶、草地、水面），模型根本没学会这类细节的重建。后来换成 DIV2K 这类包含大量自然纹理的数据集，提升立竿见影。

还有epoch 不看多，看对。小 patch 训练 30 轮可能就够用了，大 patch（192x192 以上）训练 50 轮也差不多。关键在于验证集。每训练几个 epoch 就拿验证集样本算一次 PSNR，保存效果最好的权重，而不是保存最后一轮的权重。因为 MSE loss 还有下降空间，但视觉质量可能已经过拟合了。

6. 一些只有动手踩坑才能换来的体会

超分这个方向特别适合作为深度学习的入门项目，原因在于它麻雀虽小五脏俱全：数据管道、网络设计、损失函数、训练策略、评估指标，每个环节都要亲力亲为，但又不用像目标检测那样处理复杂的后处理逻辑。做完一个完整的超分对比实验，你对卷积神经网络的理解会比刷十遍理论手册都扎实。

我个人最大的体会是：深度学习超分不是“从无到有创造细节”，而是“从经验中回忆细节”。网络能恢复出头发丝和树叶纹理，是因为它在训练集里见过无数根头发丝和无数片树叶，它学到的是一种统计规律。如果某一天你让它处理一张外星生物的照片，那些不存在的先验知识它就编不出来了，而这恰恰是超分这个问题最迷人的地方——算法永远在有限信息里做最合理的猜测。

如果你也想动手试试，建议从 ESPCN 开始。它的代码量不大，训练速度快，效果又明显优于插值，尤其适合第一次跑通超分全流程。我已经把完整的训练和评估脚本整理出来了，你拿到之后可以先跑一遍小数据集，然后换自己的图片对比，相信很快就能理解为什么深度学习超分能碾压传统插值。