PyTorch实战SRCNN：从零实现图像超分辨率与避坑指南

简介：这份资源面向图像超分方向的初学者与PyTorch入门者，用经典SRCNN模型打通从数据准备到训练、测试的完整流程，帮助理解超分辨率的基本原理与工程实现。压缩包共28个文件、约74.6MB，包含6个Python脚本负责数据预处理、模型定义、训练与测试，7个pth权重文件与2个h5数据集文件可直接加载，另有bmp图像用于对比超分与双三次插值效果，以及README说明与运行结果记录。已有2977人学习下载，说明其上手门槛较低、参考价值较高。资源内置数据集与预训练权重，解压后按说明即可运行训练或测试，参数中num_works一般电脑改为0即可，适合想快速复现SRCNN、观察重建效果并在此基础上做改进实验的读者。

1. 从一张糊图说起：SRCNN 为什么值得你亲手跑一遍

手里有一批低分辨率素材，放大后边缘发虚、纹理糊成一团，这是做图像超分时最常遇到的场景。SRCNN（Super-Resolution Convolutional Neural Network）是深度学习做超分里绕不开的起点，它用三层卷积就把「低清到高清」的映射学了出来，结构简单到可以在单卡上几十分钟跑完一轮训练。这份 PyTorch 实现适合两类人：刚接触图像超分、想搞懂 CNN 怎么做像素级回归的新手，以及想拿一个干净基线去对比后续 SR 模型（比如 FSRCNN、ESPCN）的开发者。它不依赖复杂框架，数据准备、模型定义、训练、推理四块拆得清楚，改起来没有心理负担。

2. 项目结构与技术选型：三层卷积怎么撑起超分任务

2.1 目录组织与模块职责

拿到这份源码，先别急着敲命令，把目录扫一遍能省很多事。常见的组织方式是这样：

srcnn/ ├── data/ │ ├── train/ # 训练集，高清图 │ └── val/ # 验证集 ├── datasets.py # 数据集加载与预处理 ├── model.py # SRCNN 网络定义 ├── train.py # 训练入口 ├── inference.py # 单图/批量推理 ├── utils.py # PSNR、图像读写、下采样 └── checkpoints/ # 权重保存目录

datasets.py负责把高清图用双三次插值下采样成低清图，再和原图配对返回。model.py只做一件事：定义三层卷积。train.py串起数据、模型、损失、优化器。inference.py加载权重后对任意图片做超分。这种拆法的好处是，你想换数据集只动datasets.py，想换网络结构只动model.py，互不干扰。

2.2 为什么是三层卷积

SRCNN 的核心判断是：超分本质上是像素级的回归问题，不需要池化、不需要全连接，卷积层足够提取局部纹理和边缘。三层各司其职：

• 第一层：从输入通道（通常是 YCbCr 的 Y 通道，1 通道）映射到 64 或 128 维特征，卷积核 9×9，负责捕捉大范围结构。
• 第二层：64→32 维，卷积核 1×1 或 5×5，做非线性映射，把低维特征压到更抽象的空间。
• 第三层：32→1 维，卷积核 5×5，重建输出像素。

激活函数用 ReLU，只有前两层加，最后一层不加，因为输出是连续像素值，不需要非线性截断。这个设计放到今天看很朴素，但它把「超分 = 端到端回归」这件事讲明白了。

2.3 数据准备的关键参数

训练前必须确认两件事：输入是单通道还是三通道，以及上采样倍数。SRCNN 原论文在 YCbCr 空间的 Y 通道上训练，推理时再把 Cb、Cr 用双三次插值放大后合并。如果你直接用 RGB 三通道训练，参数量会涨，收敛也慢一些。常见做法是：

# utils.py 中的下采样逻辑 import cv2 import numpy as np def downsample_image(img, scale=3): """用双三次插值把高清图缩小，模拟低清输入""" h, w = img.shape[:2] low = cv2.resize(img, (w // scale, h // scale), interpolation=cv2.INTER_CUBIC) # 再放大回原尺寸，作为网络输入（保持尺寸一致） low = cv2.resize(low, (w, h), interpolation=cv2.INTER_CUBIC) return low

这里有个容易忽略的点：低清图放大回原尺寸后，网络学的是「从模糊到清晰」的残差式映射，而不是直接学放大。scale参数决定超分倍数，训练时用 2 或 3 比较稳，4 倍以上边缘恢复会明显吃力。

提示：如果显存吃紧，把训练图块裁成 128×128 或 96×96，比整图塞进去更实际。

3. 核心模块拆解：模型定义、训练循环与损失函数

3.1 SRCNN 网络定义逐行讲

model.py是整个项目的心脏，代码不长，但每一层都有讲究：

import torch import torch.nn as nn class SRCNN(nn.Module): def __init__(self, num_channels=1): super(SRCNN, self).__init__() # 第一层：9x9 卷积，提取大范围结构特征 self.conv1 = nn.Conv2d(num_channels, 64, kernel_size=9, padding=4) # 第二层：1x1 卷积，做非线性映射，压缩特征维度 self.conv2 = nn.Conv2d(64, 32, kernel_size=1, padding=0) # 第三层：5x5 卷积，重建输出像素 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

padding的设置保证每层输出尺寸和输入一致：9×9 卷积配 padding=4，5×5 配 padding=2，1×1 配 0。num_channels默认 1，对应 Y 通道；如果你用 RGB，改成 3 即可。inplace=True省一点显存，但如果你要做特征可视化，建议关掉，否则 ReLU 会覆盖输入。

3.2 训练循环与损失选择

训练脚本的核心逻辑是：取一批低清图，前向传播得到超分结果，和对应高清图算损失，反向传播更新权重。损失函数用 MSE 最直接：

# train.py 关键片段 import torch.optim as optim from model import SRCNN from datasets import SRCNNDataset from torch.utils.data import DataLoader device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = SRCNN(num_channels=1).to(device) criterion = nn.MSELoss() optimizer = optim.Adam(model.parameters(), lr=1e-4) train_loader = DataLoader(SRCNNDataset("data/train"), batch_size=16, shuffle=True) for epoch in range(100): model.train() running_loss = 0.0 for low, high in train_loader: low, high = low.to(device), high.to(device) optimizer.zero_grad() output = model(low) loss = criterion(output, high) loss.backward() optimizer.step() running_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.6f}")

lr=1e-4是 Adam 在超分任务上的常用起点，太大容易震荡，太小收敛慢。batch_size=16在 8GB 显存上跑 128×128 图块没问题。每轮打印平均损失，如果损失卡在某个值不降，先检查数据配对是否正确——低清和高清图有没有错位，这是血泪经验里排第一的翻车点。

3.3 推理与 PSNR 评估

训练完要验证效果，inference.py负责加载权重并输出超分图，utils.py里的 PSNR 计算用来量化：

# utils.py 中的 PSNR 计算 import math import numpy as np def calculate_psnr(img1, img2): """计算两张图的 PSNR，输入为 0-255 的 uint8 数组""" mse = np.mean((img1.astype(np.float64) - img2.astype(np.float64)) ** 2) if mse == 0: return float('inf') return 20 * math.log10(255.0 / math.sqrt(mse))

PSNR 越高说明像素误差越小，但注意它和人眼感知不完全一致。SRCNN 在 Set5 这类小数据集上，3 倍超分通常能到 30dB 以上，具体数值取决于训练轮数和数据量。推理时记得把模型切到eval()模式，并加上torch.no_grad()，否则显存会白白浪费。

4. 避坑与排查：训练不收敛、显存爆炸、颜色偏移

4.1 损失不降反升

现象：训练几个 epoch 后 loss 突然变成 NaN 或大幅波动。原因通常是学习率过大，或者数据里有异常值（比如全黑图、损坏文件）。解决：把lr降到 1e-5 试一轮，同时在datasets.py里加一层过滤，跳过尺寸过小或读取失败的图片。

4.2 显存不够用

现象：报CUDA out of memory。原因可能是 batch_size 太大、图块尺寸太大，或者忘了在推理时加torch.no_grad()。解决：先把 batch_size 降到 8 或 4，再把训练图块裁到 96×96；推理阶段务必用with torch.no_grad():包住前向传播。

4.3 输出图颜色发灰或偏色

现象：超分结果整体发灰，或者颜色和原图对不上。原因多半是只处理了 Y 通道，合并时 Cb、Cr 没有正确放大，或者 RGB 和 BGR 通道顺序搞反了。解决：确认cv2.imread读进来是 BGR，如果按 RGB 处理要先转换；YCbCr 合并时用cv2.merge把三个通道拼回去再转回 BGR。

4.4 验证集 PSNR 远低于训练集

现象：训练 loss 很低，但验证集 PSNR 上不去。原因是过拟合，训练集太小或和验证集分布差异大。解决：加数据增强（随机裁剪、翻转），或者把验证集换一批不同来源的图，别用训练集的子集当验证。

4.5 推理速度慢得离谱

现象：单张图要好几秒。原因可能是模型没放到 GPU，或者输入图尺寸太大。解决：确认model.to(device)和输入 tensor 都在同一设备；大图可以先分块推理再拼接，避免一次性塞进显存。

5. 二次开发与改造：从 SRCNN 到你的超分基线

5.1 换损失函数：MSE 之外的选择

MSE 优化的是像素平均误差，结果偏平滑，纹理细节容易丢。想提升感知质量，可以换成 L1 损失或组合损失：

# 用 L1 + 感知损失的组合示例 class CombinedLoss(nn.Module): def __init__(self, alpha=0.8): super().__init__() self.alpha = alpha self.l1 = nn.L1Loss() self.mse = nn.MSELoss() def forward(self, pred, target): return self.alpha * self.l1(pred, target) + (1 - self.alpha) * self.mse(pred, target)

alpha控制 L1 和 MSE 的权重，0.8 是我试过比较稳的起点。L1 对异常值更鲁棒，训练初期 loss 下降会慢一点，但边缘更锐。

5.2 加深网络或引入残差连接

SRCNN 只有三层，感受野有限。想提升效果，最直接的改法是加残差连接，让网络学残差而不是完整映射：

class SRCNNResidual(nn.Module): def __init__(self, num_channels=1): super().__init__() self.conv1 = nn.Conv2d(num_channels, 64, 9, padding=4) self.conv2 = nn.Conv2d(64, 32, 1) self.conv3 = nn.Conv2d(32, num_channels, 5, padding=2) self.relu = nn.ReLU(inplace=True) def forward(self, x): identity = x out = self.relu(self.conv1(x)) out = self.relu(self.conv2(out)) out = self.conv3(out) return out + identity # 残差连接

这样改完，网络只需要学「模糊图到高清图的差值」，收敛更快，PSNR 通常能涨 0.5 到 1dB。注意输入输出通道要一致，否则加法对不上。

5.3 验证改造是否有效的固定流程

每次改完模型或损失，别凭感觉判断好坏。我一般固定走这三步：第一，用同一批验证图跑 PSNR，和改之前的基线对比；第二，抽三张典型图（边缘多的、纹理密的、平滑的）肉眼对比；第三，记录训练时间和显存占用，确认没有为了涨 0.2dB 把资源翻倍。这套流程能过滤掉大部分「看起来变好了」的错觉。

5.4 一个容易忽略的细节：权重初始化

SRCNN 对初始化比较敏感，默认的 PyTorch 初始化有时会让第一层输出方差过大。常见做法是用 Kaiming 初始化：

def weights_init(m): if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.zeros_(m.bias) model.apply(weights_init)

加在模型实例化之后、训练之前。这一步不写也能跑，但写了之后训练初期的 loss 曲线会平滑很多，少走几个 epoch 的弯路。

从那以后我每次动网络结构，都先把基线 PSNR 和训练曲线存下来，改完再跑一遍对比，不然很容易把「随机种子带来的波动」当成改进。希望帮到你。

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