CGAN论文详解与代码详解

本是古典何须时尚 2023-06-14 15:55 18阅读 0赞

from: [https://mp.weixin.qq.com/s?\_\_biz=Mzg5NTEwNjQ3Ng==&mid=2247484324&idx=1&sn=57f25bc89164b8ef6ad1234f8bcfb49b&chksm=c0142f67f763a6718bb1f4bf35dced93cecdac0f128839f67e7e5aacd8ea7aeea9296193731a&mpshare=1&scene=1&srcid=1108VCtC1j9NzHgSvKVUcFBr&sharer\_sharetime=1573207840909&sharer\_shareid=bcd65ed3e6918861746f708528ff9349&key=0dd8ea2ddf54b7b6bc6891811a31087e753a1d82b9c5a3ecd66f1122575f70364473cea7635e03ea3707e0d794f8061c0c6342fbdf50271d49c2d50958171e5428f012e61a56499a7dbae611d569bd47&ascene=1&uin=MjI0NDQyMzUwMA%3D%3D&devicetype=Windows+10&version=62070158&lang=en&pass\_ticket=LYK2FsN7veBklpbeKcHMb1K3blwAGAaoIsKPfv%2FLYc7XPgx5%2FHhkB0YEcx6fmTZh][https_mp.weixin.qq.com_s_biz_Mzg5NTEwNjQ3Ng_mid_2247484324_idx_1_sn_57f25bc89164b8ef6ad1234f8bcfb49b_chksm_c0142f67f763a6718bb1f4bf35dced93cecdac0f128839f67e7e5aacd8ea7aeea9296193731a_mpshare_1_scene_1_srcid_1108VCtC1j9NzHgSvKVUcFBr_sharer_sharetime_1573207840909_sharer_shareid_bcd65ed3e6918861746f708528ff9349_key_0dd8ea2ddf54b7b6bc6891811a31087e753a1d82b9c5a3ecd66f1122575f70364473cea7635e03ea3707e0d794f8061c0c6342fbdf50271d49c2d50958171e5428f012e61a56499a7dbae611d569bd47_ascene_1_uin_MjI0NDQyMzUwMA_3D_3D_devicetype_Windows_10_version_62070158_lang_en_pass_ticket_LYK2FsN7veBklpbeKcHMb1K3blwAGAaoIsKPfv_2FLYc7XPgx5_2FHhkB0YEcx6fmTZh]

作者：戴璞微  
作者微信：dpw19960712  
作者QQ：771830171  
微信公众号：AI那点小事  
知乎专栏：AI那点小事  
CSDN博客：https://daipuweiai.blog.csdn.net/  
CSDN博客原文链接：https://daipuweiai.blog.csdn.net/article/details/102962215  
知乎专栏原文链接：https://zhuanlan.zhihu.com/p/90835081

### 前言 ###

自从10月15号在广州的实习结束后，这将近1个月的时间由于学校各种实习相关手续、答辩和赶上毕业论文开题的节奏等原因，因此相关实习结束之前相关笔记没有及时。从今天开始，将恢复相关博客的更新。

在之前我们介绍了DCGAN与原始GAN的相关理论，并给出了DCGAN生成手写数字图像的代码。若有兴趣请分别移步如下链接：

1.  [【GAN】一、利用keras实现DCGAN生成手写数字图像][GAN_keras_DCGAN]
2.  [【GAN】二、原始GAN论文详解][GAN_GAN]
3.  [【GAN】三、DCGAN论文详解][GAN_DCGAN]

**本篇博客我们将介绍CGAN（条件GAN）论文的相关细节**。CGAN的论文网址请移步：https://arxiv.org/pdf/1411.1784.pdf。CGAN生成手写数字的keras代码请移步：https://github.com/Daipuwei/CGAN-mnist。

### 一、 GAN回顾 ###

为了兼顾CGAN的相关理论介绍，我们首先回顾GAN相关细节。GAN主要包括两个网络，一个是生成器和判别器，生成器的目的就是将随机输入的高斯噪声映射成图像（“假图”），判别器则是判断输入图像是否来自生成器的概率，即判断输入图像是否为假图的概率。

在这里我们假设数据为，生成器的数据分布为，噪声分布为![format_png][]，那么噪声的结果可以记![format_png 1][],数据在判别器上的结果为![format_png 2][]。

那么**GAN的目的就是无中生有，以假乱真。即要使得生成器生成的所谓的"假图"骗过判别器，那么最优状态就是生成器生成的所谓的"假图"在判别器的判别结果为0.5，不知道到底是真图还是假图**。GAN的目标函数如下：

![format_png 3][]

--------------------

### 二、CGAN网络架构详解 ###

在介绍CGAN的原理接下来介绍了CGAN的相关原理。原始的GAN的生成器只能根据随机噪声进行生成图像，至于这个图像是什么（即标签是什么我们无从得知），判别器也只能接收图像输入进行判别是否图像来使生成器。因此CGAN的主要贡献就是在原始GAN的生成器与判别器中的输入中加入额外信息。额外信可以是任何信息，例如标签。**因此CGAN的提出使得GAN可以利用图像与对应的标签进行训练，并在测试阶段 利用给定标签生成特定图像。**

在CGAN的论文中，网络架构使用的MLP（全连接网络）。在CGAN中的生成器，我们给定一个输入噪声0![format_png][]和额外信息，之后将两者通过全连接层连接到一起作为隐藏层输入。同样地，在判别器中输入图像和 额外信息也将连接到一起作为隐藏层输入。CGAN的网络架构图如下所示：

![format_png 4][]

那么，CGAN的目标函数可以表述成如下形式：  
![format_png 5][]

下面是CGAN论文中生成的手写数字图像的结果，每一行代表有一个标签，例如第一行代表标签为0的图片。

![format_png 6][]

--------------------

### 三、CGAN-MNIST代码详解 ###

接下来我们将主要介绍CGAN生成手写数字图像的keras代码。github链接为：https://github.com/Daipuwei/CGAN-mnist。首先给出CGAN的网络架构代码：

# -*- coding: utf-8 -*-
    # @Time    : 2019/10/8 13:39
    # @Author  : Dai PuWei
    # @File    : CGAN.py
    # @Software: PyCharm
    
    import os
    import cv2
    import numpy as np
    import datetime
    import matplotlib.pyplot as plt
    
    from scipy.stats import truncnorm
    
    
    from keras import Input
    from keras import Model
    from keras import Sequential
    
    from keras.layers import Dense
    from keras.layers import Activation
    from keras.layers import Reshape
    from keras.layers import Conv2DTranspose
    from keras.layers import BatchNormalization
    from keras.layers import Conv2D
    from keras.layers import LeakyReLU
    from keras.layers import Dropout
    from keras.layers import Flatten
    from keras.layers.merge import multiply
    from keras.layers.merge import concatenate
    from keras.layers.merge import add
    from keras.layers import Embedding
    from keras.utils import to_categorical
    from keras.optimizers import Adam
    from keras.utils.generic_utils import Progbar
    from copy import deepcopy
    from keras.datasets import mnist
    
    def make_trainable(net, val):
        """ Freeze or unfreeze layers
        """
        net.trainable = val
        for l in net.layers: l.trainable = val
    
    class CGAN(object):
    
        def __init__(self,config,weight_path=None):
            """
            这是CGAN的初始化函数
            :param config: 参数配置类实例
            :param weight_path: 权重文件地址，默认为None
            """
            self.config = config
            self.build_cgan_model()
    
            if weight_path is not None:
                self.cgan.load_weights(weight_path,by_name=True)
    
        def build_cgan_model(self):
            """
            这是搭建CGAN模型的函数
            :return:
            """
            # 初始化输入
            self.generator_noise_input = Input(shape=(self.config.generator_noise_input_dim,))
            self.condational_label_input = Input(shape=(1,), dtype='int32')
            self.discriminator_image_input = Input(shape=self.config.discriminator_image_input_dim)
    
            # 定义优化器
            self.optimizer = Adam(lr=2e-4, beta_1=0.5)
    
            # 构建生成器模型与判别器模型
            self.discriminator_model = self.build_discriminator_model()
            self.discriminator_model.compile(optimizer=self.optimizer, loss=['binary_crossentropy'],metrics=['accuracy'])
            self.generator_model = self.build_generator()
    
            # 构建CGAN模型
            self.discriminator_model.trainable = False
            self.cgan_input = [self.generator_noise_input,self.condational_label_input]
            generator_output = self.generator_model(self.cgan_input)
            cgan_output = self.discriminator_model([generator_output,self.condational_label_input])
            self.cgan = Model(self.cgan_input,cgan_output)
    
            # 编译
            #self.discriminator_model.compile(optimizer=self.optimizer,loss='binary_crossentropy')
            self.cgan.compile(optimizer=self.optimizer,loss=['binary_crossentropy'])
    
        def build_discriminator_model(self):
            """
            这是搭建生成器模型的函数
            :return:
            """
            model = Sequential()
    
            model.add(Dense(512, input_dim=np.prod(self.config.discriminator_image_input_dim)))
            model.add(LeakyReLU(alpha=self.config.LeakyReLU_alpha))
            model.add(Dense(512))
            model.add(LeakyReLU(alpha=self.config.LeakyReLU_alpha))
            model.add(Dropout(self.config.LeakyReLU_alpha))
            model.add(Dense(512))
            model.add(LeakyReLU(alpha=self.config.LeakyReLU_alpha))
            model.add(Dropout(self.config.LeakyReLU_alpha))
            model.add(Dense(1, activation='sigmoid'))
            model.summary()
    
            img = Input(shape=self.config.discriminator_image_input_dim)
            label = Input(shape=(1,), dtype='int32')
    
            label_embedding = Flatten()(Embedding(self.config.condational_label_num,
                                                  np.prod(self.config.discriminator_image_input_dim))(label))
            flat_img = Flatten()(img)
            model_input = multiply([flat_img, label_embedding])
            validity = model(model_input)
    
            return Model([img, label], validity)
    
    
        def build_generator(self):
            """
            这是构建生成器网络的函数
            :return:返回生成器模型generotor_model
            """
            model = Sequential()
    
            model.add(Dense(256, input_dim=self.config.generator_noise_input_dim))
            model.add(LeakyReLU(alpha=self.config.LeakyReLU_alpha))
            model.add(BatchNormalization(momentum=self.config.batchnormalization_momentum))
            model.add(Dense(512))
            model.add(LeakyReLU(alpha=self.config.LeakyReLU_alpha))
            model.add(BatchNormalization(momentum=self.config.batchnormalization_momentum))
            model.add(Dense(1024))
            model.add(LeakyReLU(alpha=self.config.LeakyReLU_alpha))
            model.add(BatchNormalization(momentum=self.config.batchnormalization_momentum))
            model.add(Dense(np.prod(self.config.discriminator_image_input_dim), activation='tanh'))
            model.add(Reshape(self.config.discriminator_image_input_dim))
    
            model.summary()
    
            noise = Input(shape=(self.config.generator_noise_input_dim,))
            label = Input(shape=(1,), dtype='int32')
            label_embedding = Flatten()(Embedding(self.config.condational_label_num, self.config.generator_noise_input_dim)(label))
    
            model_input = multiply([noise, label_embedding])
            img = model(model_input)
    
            return Model([noise, label], img)
    
        def train(self, train_datagen, epoch, k, batch_size=256):
            """
            这是DCGAN的训练函数
            :param train_generator:训练数据生成器
            :param epoch:周期数
            :param batch_size:小批量样本规模
            :param k:训练判别器次数
            :return:
            """
            time =datetime.datetime.now().strftime("%Y%m%d%H%M%S")
            model_path = os.path.join(self.config.model_dir,time)
            if not os.path.exists(model_path):
                os.mkdir(model_path)
    
            train_result_path = os.path.join(self.config.train_result_dir,time)
            if not os.path.exists(train_result_path):
                os.mkdir(train_result_path)
    
            for ep in np.arange(1, epoch+1).astype(np.int32):
                cgan_losses = []
                d_losses = []
                # 生成进度条
                length = train_datagen.batch_num
                progbar = Progbar(length)
                print('Epoch {}/{}'.format(ep, epoch))
                iter = 0
                while True:
                    # 遍历一次全部数据集，那么重新来结束while循环
                    #print("iter:{},{}".format(iter,train_datagen.get_epoch() != ep))
                    if train_datagen.epoch != ep:
                        break
    
                    # 获取真实图片，并构造真图对应的标签
                    batch_real_images, batch_real_labels = train_datagen.next_batch()
                    batch_real_num_labels = np.ones((batch_size, 1))
                    #batch_real_num_labels = truncnorm.rvs(0.7, 1.2, size=(batch_size, 1))
                    # 初始化随机噪声，伪造假图，并合并真图和假图数据集
                    batch_noises = np.random.normal(0, 1, size = (batch_size, self.config.generator_noise_input_dim))
                    d_loss = []
                    for i in np.arange(k):
                        # 构造假图标签，合并真图和假图对应标签
                        batch_fake_num_labels = np.zeros((batch_size,1))
                        #batch_fake_num_labels = truncnorm.rvs(0.0, 0.3, size=(batch_size, 1))
                        batch_fake_labels = deepcopy(batch_real_labels)
                        batch_fake_images = self.generator_model.predict([batch_noises,batch_fake_labels])
    
                        # 训练判别器
                        real_d_loss = self.discriminator_model.train_on_batch([batch_real_images,batch_real_labels],
                                                                                          batch_real_num_labels)
                        fake_d_loss = self.discriminator_model.train_on_batch([batch_fake_images, batch_fake_labels],
                                                                                          batch_fake_num_labels)
                        d_loss.append(list(0.5*np.add(real_d_loss,fake_d_loss)))
                    #print(d_loss)
                    d_losses.append(list(np.average(d_loss,0)))
                    #print(d_losses)
    
                    # 生成一个batch_size的噪声来训练生成器
                    #batch_num_labels = truncnorm.rvs(0.7, 1.2, size=(batch_size, 1))
                    batch_num_labels = np.ones((batch_size,1))
                    batch_labels = np.random.randint(0, 10, batch_size).reshape(-1, 1)
                    cgan_loss = self.cgan.train_on_batch([batch_noises,batch_labels], batch_num_labels)
                    cgan_losses.append(cgan_loss)
    
                    # 更新进度条
                    progbar.update(iter, [('dcgan_loss', cgan_losses[iter]),
                                          ('discriminator_loss',d_losses[iter][0]),
                                          ('acc',d_losses[iter][1])])
                    #print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (ep, d_losses[ep][0], 100 * d_losses[ep][1],cgan_loss))
                    iter += 1
                if ep % self.config.save_epoch_interval == 0:
                    model_cgan = "Epoch{}dcgan_loss{}discriminator_loss{}acc{}.h5".format(ep, np.average(cgan_losses),
                                                                                          np.average(d_losses,0)[0],np.average(d_losses,0)[1])
                    self.cgan.save(os.path.join(model_path, model_cgan))
                    save_dir = os.path.join(train_result_path, str("Epoch{}".format(ep)))
                    if not os.path.exists(save_dir):
                        os.mkdir(save_dir)
                    self.save_image(int(ep), save_dir)
                '''
                if int(ep) in self.config.generate_image_interval:
                    save_dir = os.path.join(train_result_path,str("Epoch{}".format(ep)))
                    if not os.path.exists(save_dir):
                        os.mkdir(save_dir)
                    self.save_image(ep,save_dir)
                '''
            plt.plot(np.arange(epoch),cgan_losses,'b-','cgan-loss')
            plt.plot(np.arange(epoch), d_losses[0], 'b-', 'd-loss')
            plt.grid(True)
            plt.legend(locs="best")
            plt.xlabel("Epoch")
            plt.ylabel("Loss")
            plt.savefig(os.path.join(train_result_path,"loss.png"))
    
        def save_image(self, epoch,save_path):
            """
            这是保存生成图片的函数
            :param epoch:周期数
            :param save_path: 图片保存地址
            :return:
            """
            rows, cols = 10, 10
    
            fig, axs = plt.subplots(rows, cols)
            for i in range(rows):
                label = np.array([i]*rows).astype(np.int32).reshape(-1,1)
                noise = np.random.normal(0, 1, (cols, 100))
                images = self.generator_model.predict([noise,label])
                images = 127.5*images+127.5
                cnt = 0
                for j in range(cols):
                    #img_path = os.path.join(save_path, str(cnt) + ".png")
                    #cv2.imwrite(img_path, images[cnt])
                    #axs[i, j].imshow(image.astype(np.int32)[:,:,0])
                    axs[i, j].imshow(images[cnt,:, :, 0].astype(np.int32), cmap='gray')
                    axs[i, j].axis('off')
                    cnt += 1
            fig.savefig(os.path.join(save_path, "mnist-{}.png".format(epoch)), dpi=600)
            plt.close()
    
        def generate_image(self,label):
            """
            这是伪造一张图片的函数
            :param label:标签
            """
            noise = truncnorm.rvs(-1, 1, size=(1, self.config.generator_noise_input_dim))
            label = np.array([label]).T
            image = self.generator_model.predict([noise,label])[0]
            image = 127.5*(image+1)
            return image

为了训练我们必须还构造一个数据集迭代器来读取小批量手写数字图像数据，数据集迭代器类的代码如下：

# -*- coding: utf-8 -*-
    # @Time    : 2019/10/8 17:29
    # @Author  : Dai PuWei
    # @File    : MnistGenerator.py
    # @Software: PyCharm
    
    import math
    import numpy as np
    from keras.datasets import mnist
    
    class MnistGenerator(object):
    
        def __init__(self,batch_size):
            """
            这是图像数据生成器的初始化函数
            :param batch_size: 小批量样本规模
            """
            (x_train,y_train),(x_test,y_test) = mnist.load_data()
            #self.x = np.concatenate([x_train,x_test]).astype(np.float32)
            self.x = np.expand_dims((x_train.astype(np.float32)-127.5)/127.5,axis=-1)
            #self.y = to_categorical(np.concatenate([y_train,y_test]),num_classes=10)
            self.y = y_train.reshape(-1,1)
            #self.y = self.y[y == ]
            #print(np.shape(self.x))
            #print(np.shape(self.y))
            self.images_size = len(self.x)
            random_index = np.random.permutation(np.arange(self.images_size))
            self.x = self.x[random_index]
            self.y = self.y[random_index]
    
            self.epoch = 1                                  # 当前迭代次数
            self.batch_size = int(batch_size)
            self.batch_num = math.ceil(self.images_size / self.batch_size)
            self.start = 0
            self.end = 0
            self.finish_flag = False                        # 数据集是否遍历完一次标志
    
        def _next_batch(self):
            """
            :return:
            """
            while True:
                #batch_images = np.array([])
                #batch_labels = np.array([])
                if self.finish_flag:  # 数据集遍历完一次
                    random_index = np.random.permutation(np.arange(self.images_size))
                    self.x = self.x[random_index]
                    self.y = self.y[random_index]
                    self.finish_flag = False
                    self.epoch += 1
                self.end = int(np.min([self.images_size,self.start+self.batch_size]))
                batch_images = self.x[self.start:self.end]
                batch_labels = self.y[self.start:self.end]
                batch_size = self.end - self.start
                if self.end == self.images_size:            # 数据集刚分均分
                    self.finish_flag = True
                if batch_size < self.batch_size:        # 小批次规模小于与预定规模,基本上是最后一组
                    random_index = np.random.permutation(np.arange(self.images_size))
                    self.x = self.x[random_index]
                    self.y = self.y[random_index]
                    batch_images = np.concatenate((batch_images, self.x[0:self.batch_size - batch_size]))
                    batch_labels = np.concatenate((batch_labels, self.y[0:self.batch_size - batch_size]))
                    self.start = self.batch_size - batch_size
                    self.epoch += 1
                else:
                    self.start = self.end
                yield batch_images,batch_labels
    
        def next_batch(self):
            datagen = self._next_batch()
            return datagen.__next__()

下面是相关训练CGAN的代码：

# -*- coding: utf-8 -*-
    # @Time    : 2019/10/8 15:43
    # @Author  : Dai PuWei
    # @File    : train.py
    # @Software: PyCharm
    
    import os
    import datetime
    
    from CGAN.CGAN import CGAN
    from Config.Config import MnistConfig
    from DataGenerator.MnistGenerator import MnistGenerator
    
    def run_main():
        """
        这是主函数
        """
        cfg =  MnistConfig()
        cgan = CGAN(cfg)
        batch_size = 512
        #train_datagen = Cifar10Generator(int(batch_size/2))
        train_datagen = MnistGenerator(batch_size)
        cgan.train(train_datagen,100000,1,batch_size)
    
    
    if __name__ == '__main__':
        run_main()

下面是训练过程中的CGAN的生成的手写数字图像。第1个epoch之后的生成结果：

![format_png 7][]

在这里插入图片描述

第10个epoch之后的生成结果：

![format_png 8][]

在这里插入图片描述

第100个epoch之后的生成结果：

![format_png 9][]

在这里插入图片描述

第1000个epoch之后的生成结果：

![format_png 10][]

在这里插入图片描述

下面是CGAN的测试代码：

# -*- coding: utf-8 -*-
    # @Time    : 2019/11/8 13:11
    # @Author  : DaiPuWei
    # @Email   : daipuwei@qq.com
    # @File    : test.py
    # @Software: PyCharm
    
    
    import os
    from CGAN.CGAN import CGAN
    from Config.Config import MnistConfig
    
    def run_main():
        """
        这是主函数
        """
        weight_path = os.path.abspath("./model/20191009134644/Epoch1378dcgan_loss1.5952800512313843discriminator_loss[0.49839333 0.7379193 ]acc[0.49839333 0.7379193 ].h5")
        result_path = os.path.abspath("./test_result")
        if not os.path.exists(result_path):
            os.mkdir(result_path)
        cfg =  MnistConfig()
        cgan = CGAN(cfg,weight_path)
        cgan.save_image(0,result_path)
    
    
    if __name__ == '__main__':
        run_main()

[https_mp.weixin.qq.com_s_biz_Mzg5NTEwNjQ3Ng_mid_2247484324_idx_1_sn_57f25bc89164b8ef6ad1234f8bcfb49b_chksm_c0142f67f763a6718bb1f4bf35dced93cecdac0f128839f67e7e5aacd8ea7aeea9296193731a_mpshare_1_scene_1_srcid_1108VCtC1j9NzHgSvKVUcFBr_sharer_sharetime_1573207840909_sharer_shareid_bcd65ed3e6918861746f708528ff9349_key_0dd8ea2ddf54b7b6bc6891811a31087e753a1d82b9c5a3ecd66f1122575f70364473cea7635e03ea3707e0d794f8061c0c6342fbdf50271d49c2d50958171e5428f012e61a56499a7dbae611d569bd47_ascene_1_uin_MjI0NDQyMzUwMA_3D_3D_devicetype_Windows_10_version_62070158_lang_en_pass_ticket_LYK2FsN7veBklpbeKcHMb1K3blwAGAaoIsKPfv_2FLYc7XPgx5_2FHhkB0YEcx6fmTZh]: https://mp.weixin.qq.com/s?__biz=Mzg5NTEwNjQ3Ng==&mid=2247484324&idx=1&sn=57f25bc89164b8ef6ad1234f8bcfb49b&chksm=c0142f67f763a6718bb1f4bf35dced93cecdac0f128839f67e7e5aacd8ea7aeea9296193731a&mpshare=1&scene=1&srcid=1108VCtC1j9NzHgSvKVUcFBr&sharer_sharetime=1573207840909&sharer_shareid=bcd65ed3e6918861746f708528ff9349&key=0dd8ea2ddf54b7b6bc6891811a31087e753a1d82b9c5a3ecd66f1122575f70364473cea7635e03ea3707e0d794f8061c0c6342fbdf50271d49c2d50958171e5428f012e61a56499a7dbae611d569bd47&ascene=1&uin=MjI0NDQyMzUwMA%3D%3D&devicetype=Windows+10&version=62070158&lang=en&pass_ticket=LYK2FsN7veBklpbeKcHMb1K3blwAGAaoIsKPfv%2FLYc7XPgx5%2FHhkB0YEcx6fmTZh
[GAN_keras_DCGAN]: http://mp.weixin.qq.com/s?__biz=Mzg5NTEwNjQ3Ng==&mid=2247484238&idx=1&sn=d7e9e37ecc91f52146dbe4dbea364f3f&chksm=c0142f8df763a69b14e10df062851ef9a91efbae856d70623389dcceeaf25aff2d1c74b09ba8&scene=21#wechat_redirect
[GAN_GAN]: http://mp.weixin.qq.com/s?__biz=Mzg5NTEwNjQ3Ng==&mid=2247484287&idx=1&sn=b2aba370c68f43c289793cd882612c27&chksm=c0142fbcf763a6aa00e559b26bd58c05af80bd53c6b5499b8ab6eb35d794249b5957814c7f06&scene=21#wechat_redirect
[GAN_DCGAN]: http://mp.weixin.qq.com/s?__biz=Mzg5NTEwNjQ3Ng==&mid=2247484297&idx=1&sn=716e2da2a76c35a78397d1e50857e5bb&chksm=c0142f4af763a65cc7379726d7c3eafba49bbd2df2ba4df701da9f7f9c15a4dd4f60083f171e&scene=21#wechat_redirect
[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVGdsZFQ3YVROTkhBSlUwVjN5elhBOU5yTjhES0xPVURnQnFSREQ4MjJrWHlWOHQ1YnFpYkx3SWcvNjQw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVGEyZDFhaFp0dmljajJBWTBEQUhaYjBqdFZFY0lJMllocE1RaWNrMmNMVkVSWHVUeHJQMjBUdXdBLzY0MA?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVG1JbHc5Mk50OHBUcWZQVTBBTEZUV0Z6ZEdrMjNEVXlVbmVYd3ZUc29XMVBZWFJUVGliU0RQN2cvNjQw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVDdKTzNFMThKaWFoMG5IZ3M5bUxQeFQ1Yk85TFpJOVV3d1pRZjRSdFVqVGlhZVpVWHZRZHNQSVVBLzY0MA?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVGx1d0pUMUZJRkExR0toa2d4NmJqVEU4YUl1NHhnT05Qb3hZbzJpY0FSQXpsRjJrZVA0bUtrV0EvNjQw?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVEdmMjMyejhhMVVGcm5RTDJYdk1JMkRHVEhpY3ZZT011QXBLYjBtT21YOU1sTVpMNVR0RUgwR0EvNjQw?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVFdHNmNpYW5NM2pCMUNNd2ljYzZvZVRKQ1R0aEdoNFJwUHV2aWJNa0tLWllQNGFucXZCaWJjWGFVWWcvNjQw?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVHI2VDZ0QkNvcHNKN05IN3JEWUpvZTFhSG9YN0lxVjNtcGRNcVZYRFFsTXRTaWNySEVhVVZJaWJBLzY0MA?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVGtHUGc0ZlZka2lianEzQlB1elRkd2pDQ3g3a3k5aGZLUFNZbkkyVjRSNHFhTjBiRmJpYzhnUEpnLzY0MA?x-oss-process=image/format,png
[format_png 9]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVFoyMzdMVlRVZ3IyQWlia0MxZk1mcDBlbDNuMDFHYnZpYnRiR0VvWU41UDVZbU00WVFlMWljWmVSdy82NDA?x-oss-process=image/format,png
[format_png 10]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9GSTZFblZNUlRYbXVLZGpDWkF5a2dtZ241ZkI3NWZMVHA3dTlBaWFnbzRBazVBMWlhUkx4SDdmYWVnZHlna0RpYWYxaElWYkQxU0xkWVczbzNmdDltUGljU1EvNjQw?x-oss-process=image/format,png