【生成对抗网络学习 其二】GAN（keras实现）代码阅读笔记

想来想去还是记录一下吧，主要是怕以后时间长忘了

好记性不如烂笔头

代码来自eriklindernoren的开源GAN实现：https://github.com/eriklindernoren/Keras-GAN

主要是添加了一些注解，大家可以参考原工程来看

因为dcgan本质上与gan没什么区别（在实现时就是把全连接层换成卷积层了而已），所以就不介绍了

依然是免责声明：水平有限，有错误请各位指正，谢谢了

接着上回的（https://www.cnblogs.com/DAYceng/p/16364564.html）继续

GAN的训练

整体结构如下

类属性

def __init__(self):
        # 定义输入图片的尺寸、通道数和噪声的维数
        self.img_rows = 28
        self.img_cols = 28
        self.channels = 1
        self.img_shape = (self.img_rows, self.img_cols,                           self.channels)
        self.latent_dim = 100

        optimizer = Adam(0.0002, 0.5)

        # 实例化判别器并指定训练时使用的优化器、loss等
        self.discriminator = self.build_discriminator()
        self.discriminator.compile(loss='binary_crossentropy',
                            optimizer=optimizer,
                            metrics=['accuracy'])

        # Build the generator
        self.generator = self.build_generator()

        # 为生成器设置一个输入层Input，形状为100维
        z = Input(shape=(self.latent_dim,))
        img = self.generator(z)

        '''
        https://blog.csdn.net/qq_38669138/article/details/109029782
        说明：这里设置不训练判别器并不是判别器就一直不会训练
        在train()中还是会通过train_on_batch的方式去训练判别器的
        原因：
            当discriminator被compile之后，即使设置了discriminator.trainable=False，
        该discriminator仍然可以通过train_on_batch的方式被训练；

            但是如果discriminator在被compile之前就把训练状态设置为False，
        那么即使是使用discriminator.train_on_batch的方式也不能训练该判别器。
        '''
        self.discriminator.trainable = False

        # 将生成器生成的图片输入判别器
        validity = self.discriminator(img)
        '''
        使用Model构建一个网络
        该网络由一个生成器层和一个判别器层组成
        通过训练该网络，让生成器尽可能骗过判别器，也就是说，该网络的作用是训练生成器
        由于之前的设置，该网络训练过程中，其判别器层不训练
        '''
        self.combined = Model(z, validity)
                 self.combined.compile(loss='binary_crossentropy', optimizer=optimizer)

生成器定义

def build_generator(self):
        # 使用Sequential方式构建生成器

        model = Sequential()

        # 输入为100维的随机噪声数据，经过第一层全连接层后输出为256维
        model.add(Dense(256, input_dim=self.latent_dim))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))

        model.add(Dense(512))# 经过第二层全连接层，输出为512维
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))

        model.add(Dense(1024))# 经过第三层全连接层，输出为1024维
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))

        # 经过第四层全连接层，输出为设置的图片的尺寸（这里是28*28，也就是784维）
        model.add(Dense(np.prod(self.img_shape), activation='tanh'))
        model.add(Reshape(self.img_shape))# Reshape成1*28*28

        model.summary()# 打印网络结构

        # 下面两句就是给定输入，获取一个输出
        # 有点类似pytorch模型类中forward函数的意思
        noise = Input(shape=(self.latent_dim,))
        img = model(noise)
        return Model(noise, img) # 返回构造好的模型

判别器定义

def build_discriminator(self):
        # 使用Sequential方式构建判别器
        model = Sequential()

        # 将输入的图片展平并输入全连接层
        model.add(Flatten(input_shape=self.img_shape))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))

        model.add(Dense(256))
        model.add(LeakyReLU(alpha=0.2))

        model.add(Dense(1, activation='sigmoid'))# 最后通过维度是1的全连接层
        model.summary()

        img = Input(shape=self.img_shape)
        validity = model(img)

        return Model(img, validity)

训练部分

 def train(self, epochs, batch_size=128, sample_interval=50):
        # 载入数据集
        (X_train, _), (_, _) = mnist.load_data()

        # 将数据调整到-1~1范围上
        X_train = X_train / 127.5 - 1.
        X_train = np.expand_dims(X_train, axis=3)# 增加X_train的维度

        # 创建标签(判断为真/假,1/0)
        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))

        for epoch in range(epochs):

            # ---------------------
            #  Train Discriminator
            # ---------------------
            # 根据索引，随机从数据集中选择图片数据
            idx = np.random.randint(0, X_train.shape[0], batch_size)
            imgs = X_train[idx]

            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))

            # 使用Sequential建立的模型可以通过predict方法返回输出值
            gen_imgs = self.generator.predict(noise)

            # 输入真实图片与生成图片训练单独判别器
            d_loss_real = self.discriminator.train_on_batch(imgs, valid)
            d_loss_fake = self.discriminator.train_on_batch(gen_imgs, fake)
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

            # ---------------------
            #  Train Generator
            # ---------------------
            # 产生正态分布的随机噪声
            noise = np.random.normal(0, 1, (batch_size, self.latent_dim))

            # 训练combined网络，注意，其中的判别器不训练
            g_loss = self.combined.train_on_batch(noise, valid)

            print ("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss))

            if epoch % sample_interval == 0:
                self.sample_images(epoch)

WGAN的训练

整体结构如下

注意：经典GAN的生成器与编码器均使用简单的全连接层构建，而其他衍生种类GAN一般使用卷积层/反卷积层代替全连接层

类属性

def __init__(self):
        # 定义输入图片的尺寸、通道数和噪声的维数
        self.img_rows = 28
        self.img_cols = 28
        self.channels = 1
        self.img_shape = (self.img_rows, self.img_cols, self.channels)
        self.latent_dim = 100

        self.n_critic = 5 # 定义判别器训练的次数
        self.clip_value = 0.01 # 设置权重裁剪参数
        optimizer = RMSprop(lr=0.00005) # 使用RMSprop优化器

        # 实例化判别器并指定训练时使用的优化器、loss等
        self.critic = self.build_critic()
        self.critic.compile(loss=self.wasserstein_loss,
            optimizer=optimizer,
            metrics=['accuracy'])

        # Build the generator
        self.generator = self.build_generator()

        # 为生成器设置一个输入层Input，形状为100维
        z = Input(shape=(self.latent_dim,))
        img = self.generator(z)

        # 设置在网络中不训练判别器
        self.critic.trainable = False

        # 将生成器生成的图片输入判别器
        valid = self.critic(img)

        '''
        使用Model构建一个网络
        该网络由一个生成器层和一个判别器层组成
        通过训练该网络，让生成器尽可能骗过判别器，也就是说，该网络的作用是训练生成器
        由于之前的设置，该网络训练过程中，其判别器层不训练
        '''
        self.combined = Model(z, valid)
        self.combined.compile(loss=self.wasserstein_loss,
            optimizer=optimizer,
            metrics=['accuracy'])

EM距离

 def wasserstein_loss(self, y_true, y_pred):
        '''
        沿着指定轴取张量的平均值，
        得到一个具有y_true * y_pred元素均值的张量
        '''
        return K.mean(y_true * y_pred)

生成器定义

def build_generator(self):

        model = Sequential()

        # 第一个全连接层，输入值是100维的噪声，输出是128*7*7=6272维的数据
        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))
        model.add(Reshape((7, 7, 128)))# Reshape成以下形状

        # 上采样，对数据进行插值，该操作将数据的行和列分别重复size[0]和size[1]次
        # 从而将特征图放大，其默认参数size为(2,2)，即放大两倍
        model.add(UpSampling2D())# (None, 14, 14, 128)
        # 引入卷积层，128个过滤器（128维），卷积核大小为4，边缘填充
        # 注：padding="same"且strides为1（默认为1）时，输入与输出图片大小一致
        # 具体计算：https://blog.csdn.net/weixin_40964777/article/details/105695251?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522165465535616781685358205%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=165465535616781685358205&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-105695251-null-null.nonecase&utm_term=%E5%8D%B7%E7%A7%AF%E5%B1%82%E8%BE%93%E5%87%BA&spm=1018.2226.3001.4450
        model.add(Conv2D(128, kernel_size=4, padding="same"))# (None, 14, 14, 128)
        # 使用BatchNormalization对卷积得到的每个特征图进行标准化处理
        model.add(BatchNormalization(momentum=0.8))# (None, 14, 14, 128)
        model.add(Activation("relu"))# 添加激活层，(None, 14, 14, 128)

        model.add(UpSampling2D())# (None, 28, 28, 128)
        # 64个过滤器（64维），卷积核大小为4，边缘填充
        model.add(Conv2D(64, kernel_size=4, padding="same"))# (None, 28, 28, 128)
        model.add(BatchNormalization(momentum=0.8))# (None, 28, 28, 128)
        model.add(Activation("relu"))# (None, 28, 28, 128)

        # 1个过滤器（1维），卷积核大小为4，边缘填充
        model.add(Conv2D(self.channels, kernel_size=4, padding="same"))#(None, 28, 28, 1)
        model.add(Activation("tanh"))

        model.summary()

        noise = Input(shape=(self.latent_dim,))
        img = model(noise)

        return Model(noise, img)

判别器定义

 def build_critic(self):

        model = Sequential()

        # 输入是28,28,1。16个过滤器（16维），卷积核大小为3，步数2，边缘填充
        model.add(Conv2D(16, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same"))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))

        # 32个过滤器（32维），卷积核大小为3，步数2，边缘填充
        '''
        这里的输出需要计算（有点奇怪，不是应该输入输出形状相同吗）
        [(14-3)+2]/2+1=6.5+1=6+1=7(当前版本tf为下取整)
        因此，经过下面卷积层后，数据的形状为(None, 7, 7, 32)
        '''
        model.add(Conv2D(32, kernel_size=3, strides=2, padding="same"))# (None, 7, 7, 32)
        # 用于在二维矩阵的四周填充0
        # 上面不填充，下面填充一行；左边不填充，右边填充一列
        model.add(ZeroPadding2D(padding=((0,1),(0,1))))# (None, 8, 8, 32)
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))# (None, 8, 8, 32)

        '''
        [(8-3)+2]/2+1=3.5+1=3+1=4(当前版本tf为下取整)
        因此，经过下面卷积层后，数据的形状为(None, 4, 4, 64)
        '''
        model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))# (None, 4, 4, 64)

        # 由于strides=1，所以形状不变，维度变为128，即(None, 4, 4, 128)
        model.add(Conv2D(128, kernel_size=3, strides=1, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        # 展平，4*4*128=2048
        model.add(Flatten())
        # 经过全连接层，输出0/1
        model.add(Dense(1))

        model.summary()

        img = Input(shape=self.img_shape)
        validity = model(img)

        return Model(img, validity)

训练部分

def train(self, epochs, batch_size=128, sample_interval=50):

        # 载入数据集
        (X_train, _), (_, _) = mnist.load_data()

        # 将数据调整到-1~1范围上
        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
        X_train = np.expand_dims(X_train, axis=3)

        # 创建标签(判断为真/假,1/0)
        valid = -np.ones((batch_size, 1))
        fake = np.ones((batch_size, 1))

        for epoch in range(epochs):

            for _ in range(self.n_critic):

                # ---------------------
                #  Train Discriminator
                # ---------------------
                # 每训练五次判别器训练一次生成器

                # 根据索引，随机从数据集中选择图片数据
                idx = np.random.randint(0, X_train.shape[0], batch_size)
                imgs = X_train[idx]

                # 产生正态分布的随机噪声
                noise = np.random.normal(0, 1, (batch_size, self.latent_dim))

                # 使用Sequential建立的模型可以通过predict方法返回输出值
                gen_imgs = self.generator.predict(noise)

                # 训练判别器
                d_loss_real = self.critic.train_on_batch(imgs, valid)
                d_loss_fake = self.critic.train_on_batch(gen_imgs, fake)
                d_loss = 0.5 * np.add(d_loss_fake, d_loss_real)

                # 梯度裁切
                for l in self.critic.layers:
                    weights = l.get_weights()
                    weights = [np.clip(w, -self.clip_value, self.clip_value) for w in weights]
                    l.set_weights(weights)

            # ---------------------
            #  Train Generator
            # ---------------------

            g_loss = self.combined.train_on_batch(noise, valid)# 训练生成器

            # Plot the progress
            print ("%d [D loss: %f] [G loss: %f]" % (epoch, 1 - d_loss[0], 1 - g_loss[0]))

            if epoch % sample_interval == 0:
                self.sample_image

WGAN-gp的训练

类属性

 def __init__(self):
        # 定义输入图片形状
        self.img_rows = 28
        self.img_cols = 28
        self.channels = 1
        self.img_shape = (self.img_rows, self.img_cols, self.channels)
        self.latent_dim = 100

        self.n_critic = 5# 定义判别器训练的次数
        optimizer = RMSprop(lr=0.00005)# 使用RMSprop优化器

        # 实例化生成器与判别器
        self.generator = self.build_generator()
        self.critic = self.build_critic()

        #-------------------------------
        # Construct Computational Graph
        #       for the Critic
        #-------------------------------

        # 当训练判别器的时候冻结生成器层
        self.generator.trainable = False

        # 规定输入样本的维数，即1*28*28（注意此处不包含batch_size）
        real_img = Input(shape=self.img_shape)

        # 同理规定输入的随机噪声的维数，即100（注意此处不包含batch_size）
        z_disc = Input(shape=(self.latent_dim,))
        # 将噪声输入生成器获得生成数据fake_img
        fake_img = self.generator(z_disc)

        # 使用判别器分别对生成数据和真实数据进行判断
        fake = self.critic(fake_img)
        valid = self.critic(real_img)

        # 使用随机权重将真实/生成数据样本混合为加权样本
        interpolated_img = RandomWeightedAverage()([real_img, fake_img])
        # (32,28,28,1)
        # Determine validity of weighted sample，对加权样本进行判别
        validity_interpolated = self.critic(interpolated_img)

        # 因为需要频繁调用gradient_penalty_loss，如果每次都写就很会变得冗余
        # 所以用partial处理一下，类似pytorch版里面定义的block函数
        # https://blog.csdn.net/qq_43426908/article/details/118530231
        partial_gp_loss = partial(self.gradient_penalty_loss,
                          averaged_samples=interpolated_img)
        partial_gp_loss.__name__ = 'gradient_penalty'

        '''
        通过Model构建一个网络（即将之前写好的网络中的各部分整合起来，搭建网络）
        该网络由三组（生成器+判别器）层组成，分别用于判别真实图片、生成图片和混合样本图片
        通过训练该网络，让判别器尽可能的识别出生成器和真混合采样图片与实图片的区别
        也就是说，该网络的作用是训练判别器
        输入：
            真实数据real_img；
            随机噪声z_disc；
        输出：
            判别器对生成数据的判断结果valid；
            判别器对真实数据的判断结果fake；
        compile参数注释（用于配置模型训练）：
            loss：用于定义整合的模型各部分使用的loss函数，
                在这里，计算valid和fake时使用self.wasserstein_loss，
                计算validity_interpolated用partial_gp_loss。
            optimizer：指定优化器
            loss_weights：损失函数权重
        使用self.wasserstein_loss和gradient_penalty_loss作为该网络的损失函数
        '''
        self.critic_model = Model(inputs=[real_img, z_disc],
                            outputs=[valid, fake, validity_interpolated])
        self.critic_model.compile(loss=[self.wasserstein_loss,
                                              self.wasserstein_loss,
                                              partial_gp_loss],
                                        optimizer=optimizer,
                                        loss_weights=[1, 1, 10])

        #-------------------------------
        # Construct Computational Graph
        #         for Generator
        #-------------------------------

        # 为了训练生成器，冻结判别器层
        # 注意：此处需要再开启生成器层，不然compile后生成器层仍然无法得到训练
        self.critic.trainable = False
        self.generator.trainable = True

        # 使用随机噪声作为输入
        z_gen = Input(shape=(self.latent_dim,))
        # 生成数据
        img = self.generator(z_gen)
        # 判断生成数据
        valid = self.critic(img)
        '''
        通过Model构建一个网络
        该网络由一个生成器层和一个判别器层组成
        通过训练该网络，让生成器尽可能骗过判别器，也就是说，该网络的作用是训练生成器
        使用self.wasserstein_loss作为该网络的损失函数
        '''
        self.generator_model = Model(z_gen, valid)
        self.generator_model.compile(loss=self.wasserstein_loss, optimizer=optimizer)

梯度惩罚项计算（感觉有点没理解完，可能以后会更新）

def gradient_penalty_loss(self, y_true, y_pred, averaged_samples):
        """
        Computes gradient penalty based on prediction and weighted real / fake samples
        """
        # 求y_pred关于averaged_samples的导数（梯度）
        # 即判别器的判断结果validity_interpolated与加权样本interpolated_img求导
        # ps：interpolated_img作为默认参数（averaged_samples）在使用partial封装时已经提供
        gradients = K.gradients(y_pred, averaged_samples)[0]
        # compute the euclidean norm by squaring ...,计算范数
        gradients_sqr = K.square(gradients)
        #   ... summing over the rows ...
        gradients_sqr_sum = K.sum(gradients_sqr,
                                  axis=np.arange(1, len(gradients_sqr.shape)))
        #   ... and sqrt
        # 基本上就是对论文中的公式的实现
        gradient_l2_norm = K.sqrt(gradients_sqr_sum)
        # compute lambda * (1 - ||grad||)^2 still for each single sample
        gradient_penalty = K.square(1 - gradient_l2_norm)
        # return the mean as loss over all the batch samples
        return K.mean(gradient_penalty)

EM距离

def wasserstein_loss(self, y_true, y_pred):
        '''
        沿着指定轴取张量的平均值，
        得到一个具有y_true * y_pred元素均值的张量
        '''
        return K.mean(y_true * y_pred)

生成器定义

def build_generator(self):
        model = Sequential()

        # 第一个全连接层，输入值是100维的噪声，输出是128*7*7=6272维的数据
        model.add(Dense(128 * 7 * 7, activation="relu", input_dim=self.latent_dim))
        model.add(Reshape((7, 7, 128)))# Reshape成以下形状

        model.add(UpSampling2D())# 上采样，对数据进行插值
        # 引入卷积层，128个过滤器（128维），卷积核大小为4，边缘填充
        model.add(Conv2D(128, kernel_size=4, padding="same"))# (None, 14, 14, 128)
        model.add(BatchNormalization(momentum=0.8))
        model.add(Activation("relu"))

        model.add(UpSampling2D())# (None, 28, 28, 128)
        model.add(Conv2D(64, kernel_size=4, padding="same"))# (None, 28, 28, 128)
        model.add(BatchNormalization(momentum=0.8))
        model.add(Activation("relu"))

        # 1个过滤器（1维），卷积核大小为4，边缘填充
        model.add(Conv2D(self.channels, kernel_size=4, padding="same"))#(None, 28, 28, 1)
        model.add(Activation("tanh"))

        model.summary()

        noise = Input(shape=(self.latent_dim,))
        img = model(noise)

        return Model(noise, img)

判别器定义

def build_critic(self):

        model = Sequential()

        # 输入是28,28,1。16个过滤器（16维），卷积核大小为3，步数2，边缘填充
        model.add(Conv2D(16, kernel_size=3, strides=2, input_shape=self.img_shape, padding="same"))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))

        '''
        这里的输出需要计算（有点奇怪，不是应该输入输出形状相同吗）
        [(14-3)+2]/2+1=6.5+1=6+1=7(当前版本tf为下取整)
        因此，经过下面卷积层后，数据的形状为(None, 7, 7, 32)
        '''
        model.add(Conv2D(32, kernel_size=3, strides=2, padding="same"))# (None, 7, 7, 32)
        # 用于在二维矩阵的四周填充0
        # 上面不填充，下面填充一行；左边不填充，右边填充一列
        model.add(ZeroPadding2D(padding=((0,1),(0,1))))# (None, 8, 8, 32)
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))

        '''
        [(8-3)+2]/2+1=3.5+1=3+1=4(当前版本tf为下取整)
        因此，经过下面卷积层后，数据的形状为(None, 4, 4, 64)
        '''
        model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))# (None, 4, 4, 64)

        # 由于strides=1，所以形状不变，维度变为128，即(None, 4, 4, 128)
        model.add(Conv2D(128, kernel_size=3, strides=1, padding="same"))
        model.add(BatchNormalization(momentum=0.8))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        # 展平，4*4*128=2048
        model.add(Flatten())
        # 经过全连接层，输出0/1
        model.add(Dense(1))

        model.summary()

        img = Input(shape=self.img_shape)
        validity = model(img)

        return Model(img, validity)

训练部分

def train(self, epochs, batch_size, sample_interval=50):

        # Load the dataset，载入数据集
        (X_train, _), (_, _) = mnist.load_data()
        # X_train:{tuple}(60000,28,28)；_:对应标签
        # 将数据调整到-1~1范围上
        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
        X_train = np.expand_dims(X_train, axis=3)

        # 创建标签(判断为真/假,1/0)
        valid = -np.ones((batch_size, 1))
        fake = np.ones((batch_size, 1))
        dummy = np.zeros((batch_size, 1))
        for epoch in range(epochs):

            for _ in range(self.n_critic):

                # ---------------------
                #  Train Discriminator
                # ---------------------
                # 每训练五次判别器训练一次生成器

                # 在60000个样本中随机选择32个组成一个batch
                idx = np.random.randint(0, X_train.shape[0], batch_size)
                imgs = X_train[idx]

                # 产生正态分布的随机噪声
                noise = np.random.normal(0, 1, (batch_size, self.latent_dim))
                # 训练判别器（此时生成器不训练）
                d_loss = self.critic_model.train_on_batch([imgs, noise],
                                                                [valid, fake, dummy])

            # ---------------------
            #  Train Generator
            # ---------------------

            # 训练生成器
            g_loss = self.generator_model.train_on_batch(noise, valid)

            # Plot the progress
            print ("%d [D loss: %f] [G loss: %f]" % (epoch, d_loss[0], g_loss))

            if epoch % sample_interval == 0:
                self.sample_images(epoch)