简介：源自经典论文《Photo-Realistic Single Image Super-Resolution》的SRGAN超分辨率重建源码包，面向深度学习和计算机视觉研究者，提供从低分辨率到高分辨率图像的完整生成对抗网络实现，涵盖数据预处理、模型构建、感知/对抗损失设计、训练与测试全流程，适合希望复现论文或在此基础上改进的读者。压缩包共29个文件，以Python脚本为主（train.py、model.py、loss.py、test_image.py等），分别负责训练、网络定义、损失计算和图像测试，配合png结果图、gitkeep目录占位及README说明，整体16.33MB，结构清晰。已有1114人学习下载，是理解感知损失与对抗损失在超分任务中作用的高人气资料。资源内包含可运行的训练/测试脚本、基准数据集评估工具以及SSIM指标模块，读者可直接运行对单张图像或视频进行超分重建，结合输出图片直观对比不同损失策略的效果，从而快速掌握SRGAN的核心思想与工程实现细节。
1. 从插值到学习：为什么超分重建要选 SRGAN
超分辨率重建这事，说起来很直白：一张低分辨率图，怎么把它放大还能看清细节。传统做法是双三次插值，算得快，但放大两倍以上就开始糊，边缘像沾了水彩笔，纹理一片浆糊。SRGAN 走的是另一条路——用生成对抗网络让模型自己“脑补”出高频细节，把放大后的图做得以假乱真。我第一次跑通 SRGAN 是在一张 64×64 的猫脸上，放大到 256×256 之后，胡须和绒毛居然是有走向的，不是那种均匀涂抹的模糊，那个视觉冲击力比 PSNR 数字涨了多少要直观得多。适合谁用？做图像修复、视频增强、医学影像辅助观察的工程师，以及对 GAN 原理有基础、想动手训一个图像生成模型的人。这篇我按自己拆过的项目来聊：SRGAN 的架构怎么落地、数据怎么准备、训练参数怎么调、哪些坑我踩过，以及最后怎么判断模型真的能用。
2. 看懂 SRGAN 的骨架：生成器与判别器结构调整到哪几个参数
2.1 生成器：残差块打底，亚像素卷积收尾
SRGAN 的生成器不是简单堆卷积层，它借了 ResNet 的思路——16 个残差块（Residual Block）提取特征，每个残差块内部是两层 3×3 卷积加 BN 加 ReLU，输入输出做恒等映射。这个结构不是拍脑袋定的，残差连接让深层网络在训练时梯度能直接回传，不会因为网络太深而消失。我拆过这个生成器，参数量大概在 900K 量级，不算大，单张 1080Ti 就能训。
关键在放大像素的尾部结构。SRGAN 没有用转置卷积做上采样，而是用了亚像素卷积（Sub-pixel Convolution），也就是 PixelShuffle。它的做法是把通道数扩成 r² 倍，然后重排成 r×r 的空间块。比如你要放大 4 倍，最后两层各做一次 2 倍 PixelShuffle，而不是一步到位 4 倍。这样做的好处是避免转置卷积那种明显的棋盘格伪影，因为重排操作不涉及补零，每个输出像素都来自真实计算的特征图位置。
import torch import torch.nn as nn class ResidualBlock(nn.Module): def __init__(self, channels=64): super(ResidualBlock, self).__init__() self.conv1 = nn.Conv2d(channels, channels, 3, 1, 1) self.bn1 = nn.BatchNorm2d(channels) self.relu = nn.ReLU(inplace=True) self.conv2 = nn.Conv2d(channels, channels, 3, 1, 1) self.bn2 = nn.BatchNorm2d(channels) def forward(self, x): residual = x out = self.relu(self.bn1(self.conv1(x))) out = self.bn2(self.conv2(out)) return out + residual class Generator(nn.Module): def __init__(self, num_resblocks=16, channels=64): super(Generator, self).__init__() self.head = nn.Conv2d(3, channels, 9, 1, 4) self.resblocks = nn.Sequential(*[ ResidualBlock(channels) for _ in range(num_resblocks) ]) self.mid = nn.Sequential( nn.Conv2d(channels, channels, 3, 1, 1), nn.BatchNorm2d(channels) ) # 两阶段 2x PixelShuffle，实现 4x 放大 self.upsample = nn.Sequential( nn.Conv2d(channels, channels * 4, 3, 1, 1), nn.PixelShuffle(2), nn.ReLU(inplace=True), nn.Conv2d(channels, channels * 4, 3, 1, 1), nn.PixelShuffle(2), nn.ReLU(inplace=True) ) self.tail = nn.Conv2d(channels, 3, 9, 1, 4) def forward(self, x): out = self.head(x) out = self.resblocks(out) out = self.mid(out) out = self.upsample(out) out = self.tail(out) return out这段代码里几个参数值得说清楚。num_resblocks=16是原论文的标准配置，改到 32 会明显加大显存占用和训练时长，但感知质量的提升有限——我试过 16 和 32 的对比，肉眼几乎看不出差别。channels=64控制特征图宽度，这是计算量和表达能力的平衡点，把它加到 128，显存直接翻倍，但效果不会有翻倍的收益。head和tail都用 9×9 大核，这是为了在网络的入口和出口获取更大的感受野，让低分辨率特征能更充分地被感知。PixelShuffle 前的卷积把通道扩到channels*4，这个 4 就是放大倍数的平方，两阶段 2 倍对应最终 4 倍输出，你如果要改 8 倍放大，就得加一层 2 倍上采样，并把通道数计算改成 6444。
2.2 判别器：不是越深越好，稳定比强大更关键
判别器的任务很简单：区分输入的图是真实高清图还是生成器伪造的。但它的设计有个微妙之处——不能做得太强。判别器如果一眼就能识破生成器的破绽，损失会迅速降到一个极小值，生成器拿不到有效的梯度信号，训练会僵住。SRGAN 原版判别器用了 VGG 风格的堆叠结构：8 层 3×3 卷积，每两层后步长 2 下采样，通道数从 64 逐层翻倍到 512，最后接两个全连接层输出一个标量。
我自己的经验是，判别器完全照抄 VGG 结构问题不大，但要注意 LeakyReLU 的斜率。原论文用 0.2，这个值如果调太小（比如 0.01），负半轴梯度太弱，判别器学得慢；调太大会让判别器对真假样本的响应差异变小。保持 0.2 就好，这是一个足够平衡的默认值。另外一个取舍是，判别器不必在训练过程中频繁更新权重——生成器每迭代一次，判别器也迭代一次，这种 1:1 的节奏在 SRGAN 场景下是稳定的。如果你发现判别器 loss 掉得太快，可以改成生成器迭代 2 次、判别器迭代 1 次，给生成器更多追赶机会。这个调整在代码里就是把两个网络的 backward 频率分开写。
2.3 损失函数：像素损失加感知损失加对抗损失，三个缺一不可
SRGAN 的损失设计是整个模型能出效果的核心。只做像素级 MSE，得到的结果会非常平滑——这是早期超分模型的问题，PSNR 指标很好看，但放大后图像缺乏纹理细节。只做对抗损失，图像会失真，全局色调可能偏移。SRGAN 的做法是三者加权：
[ L = L_{percep} + 10^{-3} L_{gen} + \text{MSE Loss} ]
感知损失是关键创新。它不是在图像像素空间算差异，而是把生成图和真实高清图都送入预训练的 VGG19，取relu5_4层的特征图，再计算这两个特征图之间的 MSE。这样做的逻辑是：高层特征图编码的是图像的语义内容（物体轮廓、纹理模式），而不是底层的颜色和噪声。网络只要把特征图中的结构重建出来，视觉上就接近真实高清图。我在实现里建议用 PyTorch 的torchvision.models.vgg19，固定在预训练权重，不改其参数，只取特征层的输出。
class PerceptualLoss(nn.Module): def __init__(self, vgg_weights='imagenet'): super(PerceptualLoss, self).__init__() from torchvision.models import vgg19 vgg = vgg19(weights=vgg_weights) # 截断到 relu5_4，后面的层对纹理敏感度下降 self.features = nn.Sequential(*list(vgg.features.children())[:36]).eval() def forward(self, sr, hr): sr_feat = self.features(sr) hr_feat = self.features(hr) return nn.functional.mse_loss(sr_feat, hr_feat)这里有个参数需要特别注意：[:36]取到 relu5_4 层，这是原论文的标准做法。有些复现版本取relu4_4（大概[:28]），效果也接近，但relu5_4的特征图尺寸更小（原图的 1/16），计算量更省，而且语义层级更高，对生成器纹理重建的引导更强。这个感知损失的权重我没用衰减策略，全程恒定，因为实验结果表明它对训练后期的稳定性影响不大。
3. 数据 pipeline：把高清图切成训练对之前，退化模型就该这么定
3.1 HR 裁剪与 LR 生成：bicubic 退化是默认答案
训练数据不是简单地把一张完整图片喂进去。显存有限，且全图尺寸不一致，训练 batch 无法对齐。标准做法是先把高清图随机裁剪成固定大小的 patch（常用 96×96 或 128×128），然后用双三次插值（bicubic）把 patch 下采样到 1/4 尺寸，得到对应的低分辨率输入（24×24 或 32×32），最后在生成器前向和损失计算时再把低分辨率图放大回原尺寸。
这里的退化模型（Degradation Model）值得展开。SRGAN 原论文用的是 bicubic 作为唯一退化方式，这也是 Set5、Set14 这些经典测试集的标准退化方式。你用 bicubic 制作的训练对去训模型，在同样是 bicubic 退化的测试集上效果最好，这叫退化匹配。但真实世界的低分辨率图往往不是纯 bicubic 退化——手机拍照的缩放、压缩、传感器噪声叠加，退化过程复杂得多。所以如果你的应用场景是真实照片放大，建议在数据增强时混入 Gaussian 模糊加噪声的退化组合，让模型见过更多退化分布。
from PIL import Image import torchvision.transforms as transforms import random def make_lr_hr_pair(hr_path, hr_crop_size=128, downscale=4): hr_img = Image.open(hr_path).convert('RGB') # 随机裁剪 HR patch，保证放大后各区域都有训练样本覆盖 i, j, h, w = transforms.RandomCrop.get_params( hr_img, output_size=(hr_crop_size, hr_crop_size)) hr_patch = transforms.functional.crop(hr_img, i, j, h, w) # 双三次下采样作为退化模型 lr_w, lr_h = hr_crop_size // downscale, hr_crop_size // downscale lr_patch = hr_patch.resize((lr_w, lr_h), Image.BICUBIC) # 归一化到 [-1, 1]，与生成器 tanh 输出对齐 to_tensor = transforms.ToTensor() hr_tensor = to_tensor(hr_patch) * 2.0 - 1.0 lr_tensor = to_tensor(lr_patch) * 2.0 - 1.0 return lr_tensor, hr_tensorhr_crop_size建议设成 128，这是效果和显存的平衡点。裁 96 也可以，但 128 配合 batch size 16，在 11GB 显存下刚好能放下。downscale=4是 SRGAN 的默认放大倍数，如果你想做 2 倍或 8 倍，只需改这个参数，但要记得同步改生成器的 PixelShuffle 层数。一个重要细节：ToTensor会先把图像归一化到 [0,1]，我在这里乘 2 减 1 变成 [-1,1]，这是为了匹配生成器最后一层 tanh 的输出范围。如果你的生成器最后一层是普通卷积没有 tanh，输出范围是 [0,1]，那就不要做这步映射，否则损失计算时会因为数值范围不一致产生偏差。
3.2 数据集组织与 DataLoader 承载：从文件到 Python 迭代器的转换
数据集分成训练集和测试集两块。训练集推荐 DIV2K，800 张 2K 分辨率高清图，专门为超分任务做的，内容涵盖人、动物、建筑、自然景观，多样性足够。如果没有下载渠道，可以用 Flickr2K 替代。测试集常用 Set5（5 张图）、Set14（14 张图）、BSD100（100 张图）。Set5 和 Set14 都是经典学术 benchmark，BSD100 里有很多自然场景，更贴近日常照片，建议三个都跑一遍，别只盯 Set5。
from torch.utils.data import Dataset, DataLoader class SRDataset(Dataset): def __init__(self, hr_dir, crop_size=128, downscale=4): self.hr_paths = sorted(glob.glob(f'{hr_dir}/*.png')) self.crop_size = crop_size self.downscale = downscale def __len__(self): return len(self.hr_paths) def __getitem__(self, idx): path = self.hr_paths[idx] lr, hr = make_lr_hr_pair(path, self.crop_size, self.downscale) return lr, hr train_loader = DataLoader( SRDataset('data/DIV2K_train_HR'), batch_size=16, shuffle=True, num_workers=4, pin_memory=True )num_workers=4是个实用设置。在 Windows 上这个值如果大于 0 可能报多进程错误，建议在if __name__ == '__main__'保护下运行；Linux 上开到 4 或者 8 都能明显缓解数据加载瓶颈——训练超分模型时，CPU 端的插值缩放计算量不小，如果数据加载跟不上的话 GPU 利用率会掉到 80% 以下。pin_memory=True能加速 CPU 到 GPU 的拷贝。另外一个常见问题是，如果你的 HR 图尺寸小于裁剪尺寸（某些数据集里可能有 64×64 的小图），会在RandomCrop.get_params时报错，数据加载前先做个过滤，把宽高都大于crop_size的图筛出来。
3.3 数据增强的选择：翻转和旋转随便用，但别动颜色通道
超分任务的数据增强和分类任务不一样。分类任务中常见的颜色抖动、随机亮度、随机对比度等增强方法，在超分里要慎重——因为 SR 学习的是从 LR 到 HR 的映射关系，颜色变换会破坏这个映射的逻辑一致性。比如你给 LR 图加了亮度扰动，但 HR 图保持原样，模型会困惑于“亮度变化到底是退化过程的一部分还是内容本身”。
安全的增强只有两个：随机水平翻转和随机旋转 90 度的倍数。这两个操作对 LR 和 HR 对是同步的，不破坏映射关系。在__getitem__里加随机数控制即可，不用引入额外的数据增强库。我的习惯是每个训练样本有 50% 概率做水平翻转，25% 概率做一次 90 度旋转，这样相当于把数据集扩大了 4 倍，对防止过拟合有实际帮助，而且完全不用增加额外计算量。
4. 训练节奏：两个阶段、三组损失，先把生成器训稳再上对抗
4.1 第一阶段：MSE 预训练生成器，给 GAN 一个能看的起点
直接从头训练完整的 SRGAN，收敛极慢且容易振荡至崩溃。更稳妥的方式是先扔掉判别器和感知损失，只用 MSE 损失预训练生成器若干轮。这时的生成器其实就是一个普通的超分 CNN，它学到的是一个保守的映射——图像放大后模糊但结构正确、色彩正确。有了这个基础，再启动对抗训练时，生成器不会因为判别器太强而完全迷失方向。
import torch.optim as optim from torch.nn import functional as F def pretrain_generator(gen, train_loader, epochs=100, lr=1e-4): opt = optim.Adam(gen.parameters(), lr=lr) mse_loss = nn.MSELoss() gen.train() for epoch in range(epochs): for lr_img, hr_img in train_loader: lr_img, hr_img = lr_img.cuda(), hr_img.cuda() opt.zero_grad() sr_img = gen(lr_img) loss = mse_loss(sr_img, hr_img) loss.backward() opt.step() print(f'Pretrain epoch {epoch + 1}, MSE loss: {loss.item():.4f}')预训练阶段的学习率用1e-4是合适的，太大了会震荡。其实更讲究的做法是采用学习率预热——先用1e-5跑几轮，再升到1e-4。原因是生成器头部的 9×9 大卷积核在初始权重时方差较大，大学习率容易把早期的梯度方向带偏。这个阶段通常跑 100 到 200 个 epoch。判断预训练结束的标准不是看 epoch 数，而是看 MSE loss 是否趋于平稳——如果 loss 还在持续下降，就多跑几轮，生成器起点越好，后面的对抗训练越顺。
4.2 第二阶段：GAN 联合训练，三组损失同时计算
预训练完成之后，把生成器权重加载回来，再接上判别器和感知损失，进入真正的 SRGAN 训练阶段。循环结构是：每轮迭代里，先生成一个 batch 的高分辨率假图，把假图和真图分别送进判别器，计算判别器损失并更新判别器；然后把假图同时送进 VGG 计算感知损失、送进判别器计算对抗损失、与真图计算像素 MSE 损失，三者加权后更新生成器。
def train_srgan(gen, disc, train_loader, epochs=500, lr_g=1e-4, lr_d=1e-4): opt_g = optim.Adam(gen.parameters(), lr=lr_g) opt_d = optim.Adam(disc.parameters(), lr=lr_d) mse = nn.MSELoss() bce = nn.BCELoss() perceptual = PerceptualLoss().cuda() for epoch in range(epochs): for lr_img, hr_img in train_loader: lr_img, hr_img = lr_img.cuda(), hr_img.cuda() batch_size = hr_img.size(0) # 第一步：训练判别器 sr_img = gen(lr_img).detach() real_pred = disc(hr_img) fake_pred = disc(sr_img) d_loss = bce(real_pred, torch.ones_like(real_pred)) + \ bce(fake_pred, torch.zeros_like(fake_pred)) opt_d.zero_grad() d_loss.backward() opt_d.step() # 第二步：训练生成器 sr_img = gen(lr_img) fake_pred = disc(sr_img) adv_loss = bce(fake_pred, torch.ones_like(fake_pred)) perce_loss = perceptual(sr_img, hr_img) pixel_loss = mse(sr_img, hr_img) g_loss = perce_loss + 1e-3 * adv_loss + pixel_loss opt_g.zero_grad() g_loss.backward() opt_g.step()注意sr_img = gen(lr_img).detach()这行——训练判别器时，生成器的梯度不能回传，否则生成器和判别器会互相打架，因为两边的参数更新目标完全对立。.detach()把生成器的输出从计算图中摘下来，让判别器损失只优化判别器自身。这一步如果漏掉，训练很快就会崩。损失函数里三个项的系数是关键超参：感知损失权重 1.0、对抗损失权重 1e-3、像素 MSE 权重 1.0。1e-3这个值意味着对抗损失对总损失的贡献是感知损失的千分之一，是一个非常克制的引导信号。为什么这么小？因为对抗损失训练初期数值波动大，权重太大容易冲刷掉像素损失和感知损失的稳定梯度。你要调整的话，建议只动对抗权重，范围在1e-4到1e-2之间，不要动感知损失的权重。
判别器学习率和生成器一样设为1e-4，没有用判别器更新的更小学习率。有些实现里会用5e-5通过降低判别器学习率来稳定训练，但这需要更多迭代才能收敛。我个人的建议是，如果观察到判别器 loss 长期低位徘徊，就手动降低判别器的学习率，这是最直接的控制手段。
4.3 预测时的归一化处理：LR 输入没有归一化是第一个坑
训练时图像被归一化到了 [-1, 1]，预测时就完全不能忘了这档子事。很多人第一次跑模型推理，直接把 0 到 255 的图片喂进生成器，得到的结果会是一张灰蒙蒙、对比度严重异常的图。预测流程要严格对称：读取图像 → 转成 tensor → 乘 2 减 1 → 进生成器 → 输出加 1 除以 2 → 转回 0-255 的 uint8。
def inference_single(gen, lr_path, output_path): lr_img = Image.open(lr_path).convert('RGB') lr_tensor = transforms.ToTensor()(lr_img).unsqueeze(0).cuda() lr_tensor = lr_tensor * 2.0 - 1.0 with torch.no_grad(): sr_tensor = gen(lr_tensor) sr_tensor = (sr_tensor + 1.0) / 2.0 sr_tensor = sr_tensor.squeeze(0).cpu() sr_img = transforms.ToPILImage()(sr_tensor.clamp(0, 1)) sr_img.save(output_path)with torch.no_grad()是必须的，推理模式不需要保存梯度，能显著降低显存占用。clamp(0, 1)是保险动作——生成器输出的偶发数值可能略越界，不裁剪的话转成图像时可能出现像素值溢出的警告。预测时的输入尺寸也有讲究——生成器输入必须是 3 通道 RGB，灰度图直接输入会报形状错误，没有广播机制。单图测试时，输入尺寸不要求是 32 的倍数，因为网络找不到全连接层，全卷积结构对输入尺寸是通用的。不过，如果输入过小（比如小于 16×16），感受野可能覆盖不到有效上下文，放大效果会很差。
5. 避坑手册：训练不收敛、色彩漂移、棋盘伪影的三类现场还原
5.1 生成器 loss 振荡或发散：先看 BN 层是否正常
现象：训练到几百轮后，生成器总损失开始大幅振荡，损失值忽高忽低，生成图像出现亮度忽明忽暗的闪烁感。判别器 loss 则持续低位，几乎没有波动。
原因排查顺序：先看学习率，GAN 架构里学习率超过2e-4振荡概率急剧上升，降回1e-4再看。第二步看 BN 层状态——BatchNorm 在训练和推理时的行为不同，它维护一个运行均值和方差。如果训练后期模型在推理时输出异常（比如生成图有明显色块断层），很可能是 BN 的 batch 统计量与运行统计量产生了偏差。这是 BN 在 GAN 里的经典问题，不少实现会在生成器里去掉 BN，效果甚至更稳定。
解决：第一阶段预训练不要去掉 BN，但第二阶段对抗训练时，把生成器所有 BN 层设置成eval()模式，即固定运行均值和方差，只让卷积层继续更新。做法是在训练循环里加一行gen.eval()后再把生成器设回train()，正交处理麻烦的话，可以手动遍历gen.modules()把 BN 层单独固定。
5.2 生成图片色彩漂移或整体偏绿偏红：损失函数权重失衡的信号
现象：生成图像在纹理细节上看起来不错，但整体色调偏移。比如天空偏紫、肤色偏绿。单独看单张图可能不觉得，和真实高清图并排对比时色差非常明显。PSNR 指标反而下降——因为颜色系统性偏移会累积大量像素误差。
原因：对抗损失权重过高或者说感知损失权重不够。感知损失的特征图对颜色信息的捕获有限，VGG 高层特征更多关注结构和内容，低层特征才编码颜色。1e-3的对抗权重下颜色漂移不太明显，但如果你调高到1e-2再训练，色偏几乎必然出现。
解决：把对抗损失权重降回1e-3或更低，同时检查判别器输入是否也做了同样的归一化。判别器如果接收的 HR 真图是 [0,1] 范围的 tensor，而生成器输出是 [-1,1] 范围的 tensor，这个 mismatch 会逼迫判别器走捷径——直接通过数值范围判断真假，而不是通过图像内容。这时生成器为了骗过判别器，会把输出数值往 [0,1] 对齐，色彩必然出问题。确保真图和假图输入判别器之前数值范围一致。
5.3 输出图像出现棋盘格伪影：放大模块的锅
现象：生成图像里出现规律排列的方块状网格，尤其在平滑区域（天空、皮肤）特别显眼，像是像素级别的棋格子。
原因：这是转置卷积（Transposed Convolution）的典型特征——转置卷积的核在重叠区域产生不均等的贡献，形成周期性的亮度条纹。严格说真正的 SRGAN 用的是 PixelShuffle，理论上不会出现这个问题，但很多 GitHub 上流传的“SRGAN 复现”代码确实用了转置卷积。另外一个偷偷引入棋盘格的方式是 loss 函数中使用了上游插值——比如某些实现为了算感知损失，把特征图用nn.Upsample插值到同一尺寸，插值方式不当会引入周期性伪影并在反向传播中被放大。
解决：确认生成器里只有 PixelShuffle，没有nn.ConvTranspose2d。如果代码里还有nn.Upsample(mode='nearest')或'bilinear'在生成器主路径上，把它们替换成 PixelShuffle。如果两个都没有但棋盘格还在，检查感知损失里的 VGG 特征层截断位置——有些 VGG 实现的前几层包含步长卷积，提取特征图的空间尺寸不是输入的分辨率，直接 mse 可能因尺寸不匹配而报错，如果代码里用了F.interpolate强行对齐，就检查插值模式。用'bilinear'别用'nearest'，后者是棋盘格的一大来源。
5.4 训练速度慢、GPU 利用率低：卡在数据增强与 CPU 瓶颈
现象：NVIDIA-smi 显示 GPU 利用率在 60% 到 80% 之间跳，显存倒没满，但一个 epoch 的耗时异常长。
原因：超分任务的数据加载流程比分类任务重很多——每次要读取 HR 图、随机裁剪、bicubic 下采样。如果num_workers=0默认主进程加载，CPU 处理跟不上 GPU 消费速度，GPU 只能空转等待。这是数据并行规模没配好的典型问题。
解决：把num_workers调到 8 到 12（在 Linux 上），并把下采样操作换成专门的图像处理库加速。Python 的Image.BICUBIC性能一般，可用 OpenCV 的cv2.resize(..., interpolation=cv2.INTER_CUBIC)，同等质量下速度快约 30%。还有一个优化点是把随机裁剪和缩放合并成一次cv2.resize加一次cv2.crop，不要把缩放分成两步。如果内存充足，另一个选择是把数据预加载进 RAM，用lmdb打包成单个数据库文件，读取比文件系统快很多，尤其当你训练上百个 epoch 时，省下的 I/O 时间相当可观。
6. 验证与部署：PSNR 与主观质量的取舍，以及一张图判断模型是否合格
6.1 客观指标怎么测：PSNR、SSIM，以及它们为什么都不完美
模型训练完成，第一件事是在测试集上跑指标。标准做法是把 HR 图按退化模型（bicubic）下采样到 LR，再送入生成器做超分，得到的 SR 图与原始 HR 图计算 PSNR 和 SSIM。
import cv2 import numpy as np import torch from skimage.metrics import peak_signal_noise_ratio, structural_similarity def evaluate(gen, test_hr_dir, downscale=4): psnr_list, ssim_list = [], [] gen.eval() for hr_path in sorted(glob.glob(f'{test_hr_dir}/*.png')): hr_img = cv2.imread(hr_path) h, w = hr_img.shape[:2] lr_img = cv2.resize(hr_img, (w // downscale, h // downscale), interpolation=cv2.INTER_CUBIC) lr_tensor = to_tensor(lr_img).unsqueeze(0).cuda() with torch.no_grad(): sr_tensor = gen(lr_tensor) sr_img = tensor_to_cv(sr_tensor) psnr = peak_signal_noise_ratio(hr_img, sr_img, data_range=255) # 多通道 SSIM 需要通道维设置，RGB 图请用 channel_axis 参数 ssim = structural_similarity(hr_img, sr_img, channel_axis=2, data_range=255) psnr_list.append(psnr) ssim_list.append(ssim) print(f'PSNR: {np.mean(psnr_list):.2f} dB, SSIM: {np.mean(ssim_list):.4f}')data_range=255是必要的——如果你输入的图像是 uint8 类型，且没有指定 data_range，skimage 会把它当成 0 到 255 之外的范围，导致指标完全失真。PSNR 的单位是 dB，SRGAN 在 Set5 上 4 倍放大的典型值在 29 到 30 dB 之间，但你要注意一个反直觉现象——SRGAN 的 PSNR 往往比纯 MSE 训练的模型低 0.5 到 1 dB，因为对抗损失故意让生成器产生锐利的纹理，而不是平滑的近似解，这在像素层面会拉大误差。所以 PSNR 低不代表模型差，恰恰可能是生成图像更有质感、更接近人眼感受的方向。SSIM 衡量的是结构相似度，它比 PSNR 稍好一些，但也线性化地对待局部细节，仍不能完全等价于主观质量。
6.2 一张图判断模型是否合格：香蕉皮和墙面的纹理测试
指标跑了，还得用眼睛看。我习惯的三张图测试法：一张人像（看肤色过渡是否自然、头发丝是否清晰）、一张带天空的风景照（看天空是否有色带或噪点）、一张有重复纹理的墙面或布料图（看纹理是否真实、有没有玻璃感）。
合格的判别标准是：放大 4 倍后，边缘没有锯齿、平滑区域没有水彩感、纹理区域没有伪影、整体色调和原图一致。特别要做一个测试——把生成图再次缩小回原尺寸，如果和原始 LR 图差别很大，说明生成器没有忠实于输入内容，而是产生了幻觉细节，这在医学影像等要求保真的场景是不可接受的。
我踩过的一个坑是，用训练集里的图测效果，指标和观感都很好，拿到真实图片一测就翻车——原因很简单，训练集 DIV2K 全是高质量 2K 原图，退化方式单一，真实照片经过了 JPEG 压缩、手机 HDR 合成、光学畸变等复杂退化。从那以后我每次拿到新模型，都强制走一遍三图测试流程，加上一个真实拍摄的 LR 图测试，确认模型在分布外数据上的表现才敢往上用。希望这篇拆解能帮你少走几步弯路——至少在生成器加载完权重、看到第一张输出图之前，你心里已经有数了：这一步出来的东西到底是在往哪个方向走。
本文还有配套的精品资源，点击获取
