好像还挺好玩的GAN重制版2——Keras搭建SRGAN平台进行图片超分辨率提升

红太狼 2022-12-26 09:16 68阅读 0赞

### 好像还挺好玩的GAN重制版2——Keras搭建SRGAN平台进行图片超分辨率提升 ###

*  学习前言
 *  源码下载地址
 *  什么是SRGAN
 *  生成网络的构建
 *  判别网络的构建
 *  训练思路
 *   *  判别器的训练
     *  生成器的训练
 *  利用SRGAN生成图片

# 学习前言 #

我又死了我又死了我又死了！  
![在这里插入图片描述][20190723165901974.jpg_pic_center]

# 源码下载地址 #

[https://github.com/bubbliiiing/srgan-keras][https_github.com_bubbliiiing_srgan-keras]

喜欢的可以点个star噢。

# 什么是SRGAN #

**SRGAN出自论文Photo-Realistic Single Image Super-Resolution Using a Generative Adversarial Network。**

如果将SRGAN看作一个黑匣子，其主要的功能**就是输入一张低分辨率图片，生成高分辨率图片。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]  
该文章提到，**普通的超分辨率模型训练网络时只用到了均方差作为损失函数，虽然能够获得很高的峰值信噪比，但是恢复出来的图像通常会丢失高频细节**。

SRGAN利用**感知损失(perceptual loss)和对抗损失(adversarial loss)来提升恢复出的图片的真实感**。

# 生成网络的构建 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]  
**生成网络的构成如上图**所示，**生成网络**的作用是**输入一张低分辨率图片，生成高分辨率图片。**：

SRGAN的生成网络由**三个部分**组成。  
1、**低分辨率图像进入后会经过一个卷积+RELU函数**。  
2、然后**经过B个残差网络结构**，每个残差结构都**包含两个卷积+标准化+RELU，还有一个残差边。**  
3、然后进入**上采样部分，在经过两次上采样后，原图的高宽变为原来的4倍，实现分辨率的提升**。

**前两个部分用于特征提取，第三部分用于提高分辨率。**

def residual_block(inputs, filters):
        x = layers.Conv2D(filters, kernel_size=3, strides=1, padding='same', kernel_initializer = random_normal(stddev=0.02))(inputs)
        x = layers.BatchNormalization(momentum=0.5)(x)
        x = layers.advanced_activations.PReLU(shared_axes=[1,2])(x)
    
        x = layers.Conv2D(filters, kernel_size=3, strides=1, padding='same', kernel_initializer = random_normal(stddev=0.02))(x)
        x = layers.BatchNormalization(momentum=0.5)(x)
        x = layers.Add()([x, inputs])
        return x
    
    def deconv2d(inputs):
        x = layers.Conv2D(256, kernel_size=3, strides=1, padding='same', kernel_initializer = random_normal(stddev=0.02))(inputs)
        x = SubpixelConv2D(scale=2)(x)
        x = layers.advanced_activations.PReLU(shared_axes=[1,2])(x)
        return x
    
    def build_generator(lr_shape, scale_factor, num_residual=16):
        #-----------------------------------#
        #   获得进行上采用的次数
        #-----------------------------------#
        upsample_block_num = int(math.log(scale_factor, 2))
        img_lr = layers.Input(shape=lr_shape)
    
        #--------------------------------------------------------#
        #   第一部分，低分辨率图像进入后会经过一个卷积+PRELU函数
        #--------------------------------------------------------#
        x = layers.Conv2D(64, kernel_size=9, strides=1, padding='same', kernel_initializer = random_normal(stddev=0.02))(img_lr)
        x = layers.advanced_activations.PReLU(shared_axes=[1,2])(x)
    
        short_cut = x
        #-------------------------------------------------------------#
        #   第二部分，经过num_residual个残差网络结构。
        #   每个残差网络内部包含两个卷积+标准化+PRELU，还有一个残差边。
        #-------------------------------------------------------------#
        for _ in range(num_residual):
            x = residual_block(x, 64)
    
        x = layers.Conv2D(64, kernel_size=3, strides=1, padding='same', kernel_initializer = random_normal(stddev=0.02))(x)
        x = layers.BatchNormalization(momentum=0.5)(x)
        x = layers.Add()([x, short_cut])
    
        #-------------------------------------------------------------#
        #   第三部分，上采样部分，将长宽进行放大。
        #   两次上采样后，变为原来的4倍，实现提高分辨率。
        #-------------------------------------------------------------#
        for _ in range(upsample_block_num):
            x = deconv2d(x)
    
        gen_hr = layers.Conv2D(3, kernel_size=9, strides=1, padding='same', activation='tanh')(x)
    
        return Model(img_lr, gen_hr)

# 判别网络的构建 #

**SRGAN的判别网络**由不断重复的 卷积+LeakyRELU和标准化 组成。  
对于判断网络来讲，它的**目的是判断输入图片的真假**，它的**输入是图片，输出是判断结果**。

**判断结果处于0-1之间**，利用**接近1代表判断为真图片，接近0代表判断为假图片。**

**判断网络的构建和普通卷积网络差距不大，都是不断的卷积对图片进行下采用，在多次卷积后，最终接一次全连接判断结果。**

实现代码如下：

def d_block(inputs, filters, strides=1):
        x = layers.Conv2D(filters, kernel_size=3, strides=strides, padding='same', kernel_initializer = random_normal(stddev=0.02))(inputs)
        x = layers.BatchNormalization(momentum=0.5)(x)
        x = layers.LeakyReLU(alpha=0.2)(x)
        return x
    
    def build_discriminator(hr_shape):
        inputs = layers.Input(shape=hr_shape)
    
        x = layers.Conv2D(64, kernel_size=3, strides=1, padding='same', kernel_initializer = random_normal(stddev=0.02))(inputs)
        x = layers.LeakyReLU(alpha=0.2)(x)
    
        x = d_block(x, 64, strides=2)
        x = d_block(x, 128)
        x = d_block(x, 128, strides=2)
        x = d_block(x, 256)
        x = d_block(x, 256, strides=2)
        x = d_block(x, 512)
        x = d_block(x, 512, strides=2)
    
        x = layers.GlobalAveragePooling2D()(x)
        x = layers.Dense(1024, kernel_initializer = random_normal(stddev=0.02))(x)
        x = layers.LeakyReLU(alpha=0.2)(x)
        validity = layers.Dense(1, activation='sigmoid', kernel_initializer = random_normal(stddev=0.02))(x)
        return Model(inputs, validity)

# 训练思路 #

DCGAN的训练可以分为生成器训练和判别器训练：  
**每一个step中一般先训练判别器，然后训练生成器。**

## 判别器的训练 ##

在**训练判别器的时候我们希望判别器可以判断输入图片的真伪**，因此我们的**输入就是真图片、假图片和它们对应的标签**。

因此判别器的训练步骤如下：

**1、随机选取batch\_size个真实高分辨率图片。  
2、利用resize后的低分辨率图片，传入到Generator中生成batch\_size个虚假高分辨率图片。  
3、真实图片的label为1，虚假图片的label为0，将真实图片和虚假图片当作训练集传入到Discriminator中进行训练。**  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3][]

## 生成器的训练 ##

在**训练生成器的时候我们希望生成器可以生成极为真实的假图片**。因此我们在训练生成器需要知道**判别器认为什么图片是真图片。**

因此生成器的训练步骤如下：

**1、将低分辨率图像传入生成模型，得到虚假高分辨率图像，将虚假高分辨率图像获得判别结果与1进行对比得到loss。（与1对比的意思是，让生成器根据判别器判别的结果进行训练）。  
2、将真实高分辨率图像和虚假高分辨率图像传入VGG网络，获得两个图像的特征，通过这两个图像的特征进行比较获得loss**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]

# 利用SRGAN生成图片 #

SRGAN的库整体结构如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]  
在训练前需要准备好数据集，数据集保存在datasets文件夹里面，一般会下载Yahoo MirFlickr25k数据集数据集进行训练（GITHUB的README.MD中有链接）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]  
在完成数据集准备后，运行train.py即可开始训练。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]  
训练过程中，可在results文件夹内查看训练效果：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]

[20190723165901974.jpg_pic_center]: /images/20221120/0418499b8ab44deebb1907cba4181e7c.png
[https_github.com_bubbliiiing_srgan-keras]: https://github.com/bubbliiiing/srgan-keras
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/4009365fca8148b28c0966be88dc82f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/c464e897780e470fb658156c33d9d18d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/ca36f904c0874a7b83bb51acff7696f4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221120/217f3ee28bb74eaabef30b21095514fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221120/ab017b0bb84c4335a14c426b2af75890.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/20201204110752965.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 6]: https://img-blog.csdnimg.cn/20201204110815231.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 7]: https://img-blog.csdnimg.cn/20201204110903280.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA_size_16_color_FFFFFF_t_70_pic_center 8]: https://img-blog.csdnimg.cn/20201204110938449.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc5MTk2NA==,size_16,color_FFFFFF,t_70#pic_center