生成对抗网络(五)----------CGAN

最新推荐文章于 2024-01-31 11:23:42 发布

勤奋的小学生

最新推荐文章于 2024-01-31 11:23:42 发布

阅读量2.7k

点赞数

分类专栏：生成对抗网络文章标签： CGAN 条件式生成对抗网络 keras实现理论

本文链接：https://blog.csdn.net/gyt15663668337/article/details/90311731

版权

生成对抗网络专栏收录该内容

9 篇文章 17 订阅

订阅专栏

一、CGAN的简单介绍

我们先说一下传统机器学习中的监督学习，监督学习就是通过有标签数据集训练模型的一种机器学习方式。在分类问题上，神经网络的监督式学习可以达到比较理想的效果。我们把监督学习的想法用在生成模型上，我们想要的结果是模型根据网络的输入的标签生成对应的输出。

传统的神经网络就可以做到这一点，如下图，将标签转化为向量输入到神经网络中，得到输出图像，并且让输出图像与真实图像越来越接近就可以。这样得到的图像就是根据输入的标签得到的对应的图像。

但是，这样的设计存在一些问题。从实际效果看往往很不理想。核心的问题在于标签数据的一对多的情况。一句文本对应的图像可能会有多个，标签虽然相同，但是在内容本身上相差甚远。这样传统的神经网络会让输出结果与每一个训练结果都尽可能相近，导致生成图像非常模糊。甚至是无法分辨的情况。

因此，为了解决带标签数据的生成问题，研究者们在GAN的基础上提出了条件式生成对抗网络的概念。也就是CGAN。CGAN可以通过参数的控制来指导数据的生成，解决传统神经网络无法很好地控制数据生成的模式。

二、CGAN的理论

我们先来看一下传统GAN的目标函数，在生成器和判别器的训练过程中模型的目标是取得一个极小极大值。

$\underset{G}{min} \underset{D}{max}V(D,G)=E_{x\sim p_{data}(x)}[logD(x)]+E_{z\sim p_{z}(z)}[log(1-D(G(z)))]$

而CGAN是对GAN的一个扩充，在原有的网络结构的情况下，对判别器和生成器的输入都加上一个额外的辅助信息y，这个y就是该数据的分类标签。接下来，我们看一下CGAN的目标函数，与传统的GAN目标函数没有什么区别，只是对判别器的输入x和生成器的输入z都加上了条件y。

$\underset{G}{min} \underset{D}{max}V(D,G)=E_{x\sim p_{data}(x)}[logD(x|y)]+E_{z\sim p_{z}(z)}[log(1-D(G(z|y)))]$

下图是CGAN的网络结构示意图：

我们再分析一下网络的具体架构，对于生成器。输入为标签c和噪声z，经过生成器G，得到图像x=G(c,z)。此时，图像x是由c和z共同决定的。

对于判别器，输入数据x和标签c。得到的一个分数，这个分数用来衡量输入的图像x是真是假和输入的图像x和标签c是否匹配。我们的输出给分情况分为，(正确的标签，正确的图像): 1，(正确的标签，错误的图像: 0，(错误的标签，正确的图像): 0。下面是两种判别器的架构：

第一种：输入x和c经过各自网络提取特征，在一起输入Network得到分数。

第二种：x输入一个网络得到输出用来衡量x是真是假，在与c一起输入网络。得到x与c是否匹配。

最后，我们的网络就会根据输入的标签就能生成我们想要的数据。

三、CGAN的代码实现(keras)

1. 导包

from __future__ import print_function, division

from keras.datasets import mnist
from keras.layers import Input, Dense, Reshape, Flatten, Dropout, multiply
from keras.layers import BatchNormalization, Embedding
from keras.layers.advanced_activations import LeakyReLU
from keras.models import Sequential, Model
from keras.optimizers import Adam

import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf

config = tf.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.Session(config=config)

2. 初始化

class CGAN():
    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.num_classes = 10
        self.latent_dim = 100

        optimizer = Adam(0.0002, 0.5)

        # 构建并且编译判别器
        self.discriminator = self.build_discriminator()
        self.discriminator.compile(loss=['binary_crossentropy'],
                                   optimizer=optimizer,
                                   metrics=['accuracy'])

        # 构建生成器
        self.generator = self.build_generator()

        # 定义输入，生成图片
        noise = Input(shape=(100,))
        label = Input(shape=(1,))
        img = self.generator([noise, label])

        # 冻结判别器
        self.discriminator.trainable = False

        # 获得判别结果
        valid = self.discriminator([img, label])

        self.combined = Model([noise, label], valid)
        self.combined.compile(loss=['binary_crossentropy'],
                              optimizer=optimizer)

3. 构建生成器

     def build_generator(self):

        model = Sequential()

        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))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(1024))
        model.add(LeakyReLU(alpha=0.2))
        model.add(BatchNormalization(momentum=0.8))
        model.add(Dense(np.prod(self.img_shape), activation='tanh'))
        model.add(Reshape(self.img_shape))

        model.summary()

        noise = Input(shape=(self.latent_dim,))
        label = Input(shape=(1,), dtype='int32')
        label_embedding = Flatten()(Embedding(self.num_classes, self.latent_dim)(label))

        model_input = multiply([noise, label_embedding])

        img = model(model_input)

        return Model([noise, label], img)

4. 构建判别器

    def build_discriminator(self):

        model = Sequential()

        model.add(Dense(512, input_dim=np.prod(self.img_shape)))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.4))
        model.add(Dense(512))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.4))
        model.add(Dense(1, activation='sigmoid'))

        model.summary()

        img = Input(shape=self.img_shape)
        label = Input(shape=(1,), dtype='int32')

        label_embedding = Flatten()(Embedding(self.num_classes, np.prod(self.img_shape))(label))
        flat_img = Flatten()(img)

        model_input = multiply([flat_img, label_embedding])

        validity = model(model_input)

        return Model([img, label], validity)

5. 训练

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

        (X_train, y_train), (_, _) = mnist.load_data()

        X_train = (X_train.astype(np.float32) - 127.5) / 127.5
        X_train = np.expand_dims(X_train, axis=3)
        y_train = y_train.reshape(-1, 1)

        # 对抗真实值
        valid = np.ones((batch_size, 1))
        fake = np.zeros((batch_size, 1))

        for epoch in range(epochs):

            # 训练判别器
            idx = np.random.randint(0, X_train.shape[0], batch_size)
            imgs, labels = X_train[idx], y_train[idx]

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

            gen_imags = self.generator.predict([noise, labels])

            d_loss_real = self.discriminator.train_on_batch([imgs, labels], valid)
            d_loss_fake = self.discriminator.train_on_batch([gen_imags, labels], fake)
            d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

            # 训练生成器

            # 标签条件
            sampled_labels = np.random.randint(0, 10, batch_size).reshape(-1, 1)

            g_loss = self.combined.train_on_batch([noise, sampled_labels], 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)

6. 显示结果

    def sample_images(self, epoch):
        r, c = 2, 5
        noise = np.random.normal(0, 1, (r * c, 100))
        sampled_labels = np.arange(0, 10).reshape(-1, 1)

        gen_imgs = self.generator.predict([noise, sampled_labels])
        gen_imgs = 0.5 * gen_imgs + 0.5

        fig, axs = plt.subplots(r, c)
        cnt = 0
        for i in range(r):
            for j in range(c):
                axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
                axs[i, j].set_title("Digit: %d" % sampled_labels[cnt])
                axs[i, j].axis('off')
                cnt += 1
        fig.savefig("images/%d.png" % epoch)
        plt.close()

7. 运行代码

if __name__ == '__main__':
    cgan = CGAN()
    cgan.train(epochs=20000, batch_size=32, sample_interval=200)

结果：

勤奋的小学生

关注

0
点赞
踩
13

收藏

觉得还不错? 一键收藏
0
评论
生成对抗网络(五)----------CGAN

一、CGAN的简单介绍我们先说一下传统机器学习中的监督学习，监督学习就是通过有标签数据集训练模型的一种机器学习方式。在分类问题上，神经网络的监督式学习可以达到比较理想的效果。我们把监督学习的想法用在生成模型上，我们想要的结果是模型根据网络的输入的标签生成对应的输出。传统的神经网络就可以做到这一点，如下图，将标签转化为向量输入到神经网络中，得到输出图像，并且让输出图像与真实图像越来越接近就可...
复制链接

扫一扫