Python实现SRGAN图像超分重建算法完整项目（含数据集与代码）

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

简介：SRGAN（超分辨率生成对抗网络）是一种基于深度学习的图像超分重建技术，能够将低分辨率图像恢复为高清晰度图像，在图像处理、计算机视觉等领域具有广泛应用。本资源提供完整的Python实现方案，包含模型代码、训练流程、常用数据集（如Set5、DIV2K等）及预处理脚本。通过生成器与判别器的对抗训练，结合感知损失与VGG网络，显著提升图像视觉质量。项目涵盖从模型定义、损失函数设计到训练优化和结果评估的全流程，支持PSNR、SSIM指标验证与图像可视化，适合初学者学习与研究人员二次开发，是掌握GAN在图像超分中应用的优质实战资源。

SRGAN：从理论到实践的超分辨率生成对抗网络深度解析

在数字影像无处不在的今天，我们每天都被海量图像包围——社交媒体上的自拍、监控摄像头捕捉的画面、医疗设备输出的扫描图……然而，并非所有图像都以理想质量呈现。一张模糊的老照片能否“复活”？一段低清视频能否变得高清流畅？这些问题催生了一个极具挑战性的研究方向： 图像超分辨率重建（Super-Resolution, SR） 。

传统方法如双线性插值或稀疏编码虽然能放大图像尺寸，但往往只能填充像素而无法真正“创造”细节，结果常常是平滑却缺乏真实感的“塑料脸”。直到2017年，一个名为 SRGAN（Super-Resolution Generative Adversarial Network） 的模型横空出世，首次将生成对抗网络（GAN）引入超分辨率任务，实现了从“看得清”到“看起来真”的跨越。🎉 它不再只是数学意义上的放大器，而是开始像人类一样“脑补”缺失的纹理与结构。

那么，SRGAN究竟是如何做到这一点的？它的核心机制是什么？又该如何完整实现并评估这样一个复杂系统？本文将带你深入SRGAN的技术内核，从GAN的基本博弈思想出发，剖析生成器与判别器的设计精髓，详解感知损失背后的视觉原理，最终构建一个可运行的完整项目。准备好了吗？让我们开启这场关于“看见不可能”的旅程吧！🚀

---

GAN的诞生：一场伪造者与鉴定师之间的艺术对决 🎨⚖️

要理解SRGAN，我们必须先回到它的灵魂所在—— 生成对抗网络（Generative Adversarial Network, GAN） 。这不仅仅是一种机器学习架构，更是一场精妙绝伦的动态博弈游戏。

想象一下这样的场景：一位画家（生成器）试图临摹一幅名画，而博物馆的艺术品鉴定专家（判别器）则负责判断眼前的画作是否为真迹。起初，这位画家的作品粗糙不堪，一眼就能被识破；但随着他不断观察专家的反应，调整笔触和色彩，他的仿制品越来越逼真。与此同时，鉴定专家也在不断升级自己的分析手段，寻找新的破绽。就这样，两人在反复较量中共同进化，最终，画家甚至能够创作出连专家都难以分辨的杰作！

这正是GAN的核心隐喻。它由两个神经网络构成：

• 生成器 $G$ ：接收一个随机噪声向量 $z$（通常来自标准正态分布），输出一张合成图像 $G(z)$；
• 判别器 $D$ ：输入一张图像 $x$，判断它是真实的还是由生成器伪造的，输出一个概率值 $D(x) \in [0,1]$。

整个系统的优化目标可以用一个极小极大（minimax）损失函数来描述：

$$
\min_G \max_D V(D, G) = \mathbb{E} {x \sim p {data}(x)}[\log D(x)] + \mathbb{E}_{z \sim p_z(z)}[\log(1 - D(G(z)))]
$$

这个公式乍一看有点吓人，其实很简单：

• 判别器想最大化 $V(D,G)$：对真实图像给出高分（$\log D(x)$ 越大越好），对假图像给出低分（$\log(1-D(G(z)))$ 越大越好）。
• 生成器想最小化 $V(D,G)$：但它希望判别器把假图当成真图，也就是让 $D(G(z))$ 接近1，从而使得 $\log(1-D(G(z)))$ 趋近于零。

换句话说，生成器的目标其实是 最大化 $\log D(G(z))$ —— 让判别器越自信地认为“这是真的”，生成器就越成功！

graph TD
    A[随机噪声 z ~ N(0,I)] --> G((生成器 G))
    G --> X[生成图像 G(z)]
    X --> D((判别器 D))
    Real[真实图像 x ~ pdata(x)] --> D
    D --> P1["D(x): 真实图像判别概率"]
    D --> P2["D(G(z)): 生成图像判别概率"]
    P1 --> Loss
    P2 --> Loss
    Loss --> UpdateD[更新判别器参数 θd]
    P2 --> UpdateG[更新生成器参数 θg]

上面这张流程图清晰展示了信息流动路径：生成器造“赝品”，判别器做“鉴定”，两者通过损失函数连接，形成闭环反馈。每一次迭代都在推动系统向更高水平的真实感迈进。

零和博弈与纳什均衡：当伪造者遇上终极鉴定家 🔍

从博弈论角度看，GAN 是典型的“二人零和博弈”——一方所得即另一方所失。如果生成器骗过了判别器，那判别器就失败了；反之亦然。这种对抗关系驱使双方不断提升能力。

理论上，当训练达到理想状态时，生成器完全学会了真实数据的分布 $p_g(x) = p_{data}(x)$，此时无论判别器怎么判断，最优策略也只能是随机猜测，即 $D^ (x) = 0.5$。这个点被称为 纳什均衡 *（Nash Equilibrium），意味着任何一方单方面改变策略都无法获得额外收益。

Goodfellow 在原始论文中证明，对于固定的生成器 $G$，最优判别器为：

$$
D^*(x) = \frac{p_{data}(x)}{p_{data}(x) + p_g(x)}
$$

将其代入原目标函数，可以推导出：

$$
C(G) = 2 \cdot JSD(p_{data} | p_g) - \log 4
$$

其中 $JSD$ 是 Jensen-Shannon 散度，衡量两个概率分布之间的差异。因此，GAN 的训练过程本质上是在最小化 JS 散度，迫使生成分布无限逼近真实分布。

度量方式	是否可导	分布无交集时表现	是否对称	适用场景
KL散度	是	∞（失效）	否	变分推断
JS散度	是	log2（常数）	是	原始GAN
Wasserstein距离	是	连续变化	是	WGAN

不过，JS 散度有个致命问题：当两个分布完全没有重叠时，梯度为零，导致生成器收不到有效反馈——这就是著名的“梯度消失”现象。这也是为什么早期 GAN 训练极其不稳定的原因之一。

后来提出的 Wasserstein GAN（WGAN） 改用 Earth Mover’s Distance（推土机距离）替代 JS 散度，即使分布不重叠也能提供有意义的梯度信号，显著提升了训练稳定性。其 critic 函数形式如下：

$$
W(p_r, p_g) = \sup_{|f| L \leq 1} \mathbb{E} {x \sim p_r}[f(x)] - \mathbb{E}_{x \sim p_g}[f(x)]
$$

约束 $|f|_L \leq 1$ 表示函数 Lipschitz 连续，通常通过权重裁剪或梯度惩罚（Gradient Penalty）实现。

下面是一个简单的 Python 示例，演示如何计算两个一维高斯分布的 JS 散度：

import numpy as np
from scipy.stats import entropy

def js_divergence(p, q):
    M = 0.5 * (p + q)
    return 0.5 * entropy(p, M) + 0.5 * entropy(q, M)

# 构造两个略有差异的分布
x = np.linspace(-5, 5, 1000)
p = np.exp(-0.5 * (x - 0)**2) / np.sqrt(2*np.pi)
q = np.exp(-0.5 * (x - 0.5)**2) / np.sqrt(2*np.pi)
p /= p.sum()
q /= q.sum()

jsd = js_divergence(p, q)
print(f"JS Divergence: {jsd:.6f}")

这段代码虽然不能直接用于训练 GAN，但它帮助我们直观理解： JS 散度越小，说明两个分布越接近 。而在实际深度学习中，我们通过神经网络间接逼近这一目标。

损失函数设计的艺术：让梯度永不枯竭 💡

GAN 的训练本质上是一个交替优化过程：先固定生成器，更新判别器；再固定判别器，更新生成器。但由于目标函数高度非凸，传统的梯度下降并不保证收敛。

原始 GAN 使用的生成器损失是：

$$
\mathcal{L} G = -\mathbb{E} {z \sim p_z}[\log(1 - D(G(z)))]
$$

但在训练初期，由于生成图像太差，判别器几乎总能正确识别，导致 $D(G(z)) \approx 0$，进而 $\log(1-D(G(z))) \approx 0$，梯度非常微弱——这就是所谓的“梯度饱和”问题。

解决方案是采用 非饱和损失 （non-saturating loss）：

$$
\mathcal{L} G^{‘} = \mathbb{E} {z \sim p_z}[\log D(G(z))]
$$

这样，当 $D(G(z))$ 很小时，$\log D(G(z))$ 是一个很大的负数，反向传播时会产生强烈的梯度激励，促使生成器快速改进。

为了提升训练稳定性，实践中还常用以下技巧：

1. 两时间尺度更新规则（TTUR） ：给判别器设置更高的学习率，使其更快收敛；
2. 标签平滑（Label Smoothing） ：将真实标签从 1 改为 0.9，防止判别器过度自信；
3. 添加噪声到输入 ：提高泛化能力；
4. 使用 Adam 或 RMSProp 优化器 ：更适合非平稳目标。

import torch
import torch.nn as nn
import torch.optim as optim

# 定义简单的GAN损失函数实现
criterion = nn.BCELoss()
real_labels = torch.ones(64, 1) * 0.9  # 标签平滑：0.9 而非 1.0
fake_labels = torch.zeros(64, 1)

# 判别器输出
d_out_real = discriminator(real_images)
d_out_fake = discriminator(generator(noise))

# 判别器损失
d_loss_real = criterion(d_out_real, real_labels)
d_loss_fake = criterion(d_out_fake, fake_labels)
d_loss = d_loss_real + d_loss_fake

# 生成器损失（非饱和）
g_loss = criterion(d_out_fake, torch.ones_like(d_out_fake))  # 希望判别器认为是真

# 优化步骤
d_optimizer.zero_grad()
d_loss.backward(retain_graph=True)
d_optimizer.step()

g_optimizer.zero_grad()
g_loss.backward()
g_optimizer.step()

注意这里的 retain_graph=True ，因为在后续生成器反向传播时还需要复用中间计算图。此外，务必确保在训练判别器时冻结生成器参数，反之亦然，避免相互干扰。

---

SRGAN 的逆袭：如何让图像不仅“大”而且“真”？

如果说传统超分辨率像是拿着放大镜看图，那 SRGAN 就是在用想象力画画。它的革命性在于： 不再追求像素级精确匹配，而是追求感知层面的真实感 。

传统方法如 SRCNN 或 EDSR 主要依赖 MSE（均方误差）作为损失函数。MSE 强制每个像素尽可能接近真实值，听起来很合理，但问题是——人眼根本不是这么看世界的！👀 我们关注的是整体结构、边缘锐利度、纹理自然性，而不是某个像素到底是 128 还是 129。

这就导致了一个尴尬局面：某些模型 PSNR 很高（数值漂亮），但图像看起来依然模糊、死板、缺少生气。就像一个人五官端正但面无表情，技术上完美，审美上失败。

SRGAN 打破了这一困境。它引入了两种全新的损失机制：

• 对抗损失（Adversarial Loss） ：借助判别器引导生成图像更具真实感；
• 感知损失（Perceptual Loss） ：利用预训练 VGG 网络提取高层语义特征，确保内容一致性。

实验表明，尽管 SRGAN 的 PSNR 可能略低于一些回归型模型，但其 SSIM 和人类评分（MOS）远超基准，真正做到了“看着舒服”。

方法	主要损失	优势	缺陷
Bicubic	无	快速简单	模糊严重
SRCNN	MSE	清晰度提升	仍偏模糊
EDSR	L1/L2	高PSNR	缺乏纹理
SRGAN	GAN + Perceptual	视觉真实感强	可能引入伪影

生成器 vs 判别器：协同进化的秘密武器 🤝

在 SRGAN 中，生成器的任务是从低分辨率图像 $I_{LR}$ 生成高分辨率图像 $I_{HR}’ = G(I_{LR})$。这个生成结果会被送入判别器 $D$，后者判断其是否属于真实高清图像集合。

判别器通常采用深层卷积神经网络（如 VGG-like 结构），逐层提取空间特征并压缩维度，最终输出一个标量概率。其输入包括两类：
- 真实样本：来自数据集的真实高分辨率图像 $I_{HR}$
- 生成样本：由生成器输出的 $G(I_{LR})$

关键在于，判别器不仅仅是“打分”，它还在教生成器“什么样的图像才算真实”：

flowchart LR
    LR[低分辨率图像 I_LR] --> Gen((生成器 G))
    Gen --> HR_gen[生成高分辨率图像 G(I_LR)]
    HR_gen --> Dis((判别器 D))
    HR_real[真实高分辨率图像 I_HR] --> Dis
    Dis --> Score["D(x): 真实性得分"]
    Score --> Loss_D
    Score --> Grad_G[∇_G: 生成器梯度]
    Grad_G --> Update_G[更新生成器参数]

生成器通过反向传播接收来自判别器的梯度信号，调整自身参数以增加 $D(G(I_{LR}))$ 的值。这意味着生成器不仅仅是在“重建像素”，而是在“学习什么样的图像会被判别器认为是真实的”。

久而久之，生成器就掌握了自然图像的统计规律：
- 合成符合 1/f 频谱特性的纹理；
- 避免出现人工痕迹（如棋盘效应、重复图案）；
- 维持局部与全局的一致性（如人脸五官协调、建筑透视正确）。

有趣的是，有些研究发现，经过充分训练的生成器甚至能在没有判别器的情况下独立产出高质量图像——因为它已经把“真实性”的概念内化成了自身的先验知识。

判别器的反馈机制：不只是打分，更是指导 🧭

判别器提供的梯度是生成器优化的核心驱动力。它的反馈可以分为三个层次：

1. 整体真实性判断 ：输出单一标量分数，生成器据此调整整体风格趋向“更真实”；
2. 局部区域修正 ：通过注意力机制或 PatchGAN 设计，在特定区域（如眼睛、文字边缘）施加更强惩罚；
3. 特征层级监督 ：某些变体在多个感受野上进行判别，允许生成器在不同尺度上优化纹理一致性。

SRGAN 常采用全卷积判别器（FCN），输出一个 $16\times16$ 的空间响应图，每个位置对应原图某个区域的真实性评分。这种方式称为“局部判别”，有助于捕捉局部纹理异常。

class Discriminator(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 64, kernel_size=3, stride=1, padding=1),
            nn.LeakyReLU(0.2),
            nn.Conv2d(64, 64, kernel_size=4, stride=2, padding=1),
            nn.BatchNorm2d(64),
            nn.LeakyReLU(0.2),
            # ... 多层降维
            nn.Conv2d(512, 1, kernel_size=4, padding=1)
        )
    def forward(self, x):
        return torch.sigmoid(self.features(x))

这个判别器结构有几个关键点值得注意：
- 使用 LeakyReLU(0.2) 防止死神经元；
- BatchNorm 提升训练稳定性；
- 最终输出为单通道特征图，经 Sigmoid 归一化为概率；
- 损失计算时可对整张图取平均，也可保留空间信息做逐像素监督。

生成器依据此反馈不断调整上采样模块（如 PixelShuffle）、残差连接强度及激活函数响应，最终产出既具高 PSNR 又富视觉美感的超分图像。

---

生成器设计之道：残差、归一化与亚像素卷积的完美融合 ✨

如果说判别器是裁判，那生成器就是运动员。SRGAN 中的生成器必须兼具“稳定发挥”和“创造力爆发”的能力。为此，研究人员精心设计了一系列关键技术组件。

残差块：让信息自由穿梭于深层网络 🛣️

深层神经网络容易出现梯度消失问题，尤其是在图像生成这类需要长距离信息传递的任务中。解决办法就是 残差网络 （ResNet）。

残差块的基本思想是：让每一层不再拟合目标输出，而是拟合输入与期望输出之间的“残差”。数学表达为：

$$
\mathbf{y} = \mathcal{F}(\mathbf{x}, {W_i}) + \mathbf{x}
$$

其中 $\mathcal{F}(\cdot)$ 是主干路径，$\mathbf{x}$ 是跳跃连接。即使 $\mathcal{F}(\cdot)$ 输出为零，信息也能无损传递。

class ResidualBlock(nn.Module):
    def __init__(self, channels):
        super(ResidualBlock, self).__init__()
        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(channels)
        self.relu = nn.ReLU(inplace=True)
        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, stride=1, padding=1)
        self.bn2 = nn.BatchNorm2d(channels)

    def forward(self, x):
        residual = x
        out = self.conv1(x)
        out = self.bn1(out)
        out = self.relu(out)
        out = self.conv2(out)
        out = self.bn2(out)
        out += residual  # 跳跃连接
        out = self.relu(out)
        return out

这种结构特别适合图像重建：低频内容（背景、颜色块）走捷径，高频细节（毛发、纹理）由主干学习补充。典型配置是堆叠 16 或 23 个残差块。

全局跳跃连接：防止“忘本”的聪明设计 🔄

更深的网络可能因为过多非线性变换导致内容失真。为此，SRGAN 引入 全局跳跃连接 ——将初始卷积层的输出直接连接到最后一个上采样层之前。

class GeneratorWithGlobalSkip(nn.Module):
    def __init__(self, scale_factor=4, in_channels=3, num_residuals=16, mid_channels=64):
        super().__init__()
        self.conv_in = nn.Conv2d(in_channels, mid_channels, kernel_size=9, padding=4)
        self.relu = nn.ReLU(inplace=True)
        self.residual_blocks = nn.Sequential(*[ResidualBlock(mid_channels) for _ in range(num_residuals)])
        self.conv_mid = nn.Conv2d(mid_channels, mid_channels, kernel_size=3, padding=1)
        self.bn_mid = nn.BatchNorm2d(mid_channels)
        self.upsample = nn.Sequential(
            nn.Conv2d(mid_channels, mid_channels * 4, kernel_size=3, padding=1),
            nn.PixelShuffle(2),
            nn.ReLU(inplace=True)
        ) if scale_factor == 4 else ...
        self.conv_out = nn.Conv2d(mid_channels, in_channels, kernel_size=9, padding=4)

    def forward(self, x):
        shortcut = self.conv_in(x)
        x = self.relu(shortcut)
        x = self.residual_blocks(x)
        x = self.conv_mid(x)
        x = self.bn_mid(x)
        x += shortcut  # 全局跳跃连接
        x = self.upsample(x)
        x = self.conv_out(x)
        return torch.tanh(x)

这个设计确保了原始低频信息得以完整保留，避免“越修越不像”。

亚像素卷积：告别棋盘伪影的优雅上采样 🌀

传统转置卷积（Deconvolution）容易产生“棋盘效应”（checkerboard artifacts），如下所示：

■□■□
□■□■
■□■□
□■□■

这是因为滤波核响应存在重叠。而 PixelShuffle 技术彻底解决了这个问题。

它的原理是：先通过普通卷积扩展通道数，再重新排列这些通道以填充更高分辨率的空间网格。

pixel_shuffle = nn.PixelShuffle(upscale_factor=2)
input_tensor = torch.randn(1, 16, 10, 10)  # [B, C*r², H, W]
output = pixel_shuffle(input_tensor)       # [B, C, H*2, W*2]

PixelShuffle 不引入额外权重，仅为重排操作，计算效率极高，且输出平滑无伪影。

---

感知损失：让机器学会“用眼看”而非“用尺量” 👁️

如果说对抗损失教会了生成器“欺骗判别器”，那感知损失则是教会它“尊重内容”。

传统 MSE 损失的问题在于它只关心像素值，不关心语义。两张图像可以有相同的 MSE 误差，但一张是自然风景，另一张是白噪音，显然前者更“合理”。

感知损失的灵感来自人类视觉系统（HVS）。我们识别图像时，大脑会分层处理信息：边缘 → 纹理 → 物体 → 场景。深度 CNN 正好模拟了这一过程。

SRGAN 使用预训练 VGG16 网络作为特征提取器，在 relu3_3 和 relu4_3 层提取特征并计算欧氏距离：

$$
L_{\text{percep}} = |\phi(I^{\text{HR}}) - \phi(I^{\text{SR}})|_2^2
$$

class VGGFeatureExtractor(nn.Module):
    def __init__(self, layer_names=['features.10']):
        super(VGGFeatureExtractor, self).__init__()
        vgg = models.vgg16(pretrained=True)
        self.features = nn.Sequential(*list(vgg.features.children())[:18])
        for param in self.features.parameters():
            param.requires_grad = False

    def forward(self, x):
        return self.features(x)

VGG 成为首选是因为它层级清晰、迁移性能好、非残差结构便于分析。

最终，SRGAN 的总损失函数为三项加权和：

$$
\mathcal{L} {\text{total}} = \lambda {\text{pixel}} L_{\text{MSE}} + \lambda_{\text{perc}} L_{\text{VGG}} + \lambda_{\text{adv}} L_{\text{adv}}
$$

典型权重设置为：$\lambda_{\text{MSE}}=1$, $\lambda_{\text{VGG}}=1$, $\lambda_{\text{adv}}=0.001$。

---

实战演练：从零搭建你的 SRGAN 项目 🛠️

现在，让我们动手实现一个完整的 SRGAN 流程。

数据准备与预处理

推荐使用 DIV2K 数据集，包含 1000 张高质量 2K 图像。

transform = transforms.Compose([
    transforms.RandomCrop(128),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5]*3, std=[0.5]*3)
])

低分辨率图像通过双三次插值下采样生成。

训练主循环

for epoch in range(num_epochs):
    for lr_img, hr_img in dataloader:
        # Train Discriminator
        fake_img = G(lr_img).detach()
        d_loss = D_adv_loss(D(hr_img), 0.9) + D_adv_loss(D(fake_img), 0)
        d_optimizer.zero_grad()
        d_loss.backward()
        d_optimizer.step()

        # Train Generator
        fake_img = G(lr_img)
        g_content = content_loss(VGG, fake_img, hr_img)
        g_adv = adversarial_loss(D(fake_img), 1)
        g_total = g_content + 1e-3 * g_adv

        g_optimizer.zero_grad()
        g_total.backward()
        g_optimizer.step()

建议判别器更新频率高于生成器（如 5:1），并在后期逐步降低对抗损失权重。

评估与可视化

除了 PSNR 和 SSIM，一定要加入主观评估。你可以用 matplotlib 对比四种图像：

fig, axes = plt.subplots(1, 4, figsize=(16, 4))
axes[0].imshow(lr_img); axes[0].set_title("LR Input")
axes[1].imshow(bicubic); axes[1].set_title("Bicubic")
axes[2].imshow(srgan_out); axes[2].set_title("SRGAN Output")
axes[3].imshow(hr_label); axes[3].set_title("Ground Truth")
plt.show()

你会发现，SRGAN 可能在数值上稍逊一筹，但视觉上明显更生动、更自然。

---

写在最后：SRGAN 的遗产与未来 🌟

SRGAN 不只是一个模型，它开启了一种新的思维方式： 图像质量不应仅由像素决定，更应由感知定义 。这一理念影响深远，催生了 ESRGAN、StyleGAN-SR、Real-ESRGAN 等一系列后续工作。

今天的你或许已经可以用手机一键修复老照片，背后正是 SRGAN 所代表的“感知优先”哲学在默默支撑。下次当你惊叹于某张超清图像时，不妨想想那个曾经在噪声中摸索、在对抗中成长的小小生成器——它不只是在放大像素，更是在努力理解什么是“真实”。✨

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

简介：SRGAN（超分辨率生成对抗网络）是一种基于深度学习的图像超分重建技术，能够将低分辨率图像恢复为高清晰度图像，在图像处理、计算机视觉等领域具有广泛应用。本资源提供完整的Python实现方案，包含模型代码、训练流程、常用数据集（如Set5、DIV2K等）及预处理脚本。通过生成器与判别器的对抗训练，结合感知损失与VGG网络，显著提升图像视觉质量。项目涵盖从模型定义、损失函数设计到训练优化和结果评估的全流程，支持PSNR、SSIM指标验证与图像可视化，适合初学者学习与研究人员二次开发，是掌握GAN在图像超分中应用的优质实战资源。

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