条件生成对抗网络CGAN

CGAN是更早使梦想资料文件出现被选为应该的GAN科学创新之1，会就是说最具影响到力的其中一种。下面来，了解CGAN的运行方式英文并且是怎样的用MNIST资料文件集实行它的小产值发行版。

CGAN原理

产生器掌握培训为操练数剧集中点的每隔价格价签产生活灵活现的范例，而判断器则掌握培训判断确实范例-价格价签对与假的范例-价格价签对。半开展GAN的判断器拿来判断实际存在范例与伪范例，还给每隔实际存在范例分配比例无误的价格价签；而CGAN中的判断器不容易掌握培训判断每个范例是每个类。它只掌握培训介绍实际存在的且范例-价格价签识别无误的对，拒绝接受不识别的对和范例为假的对。 诸如：不论是子样表量量1是简直是假，CGAN的判别器都同意该（子样表量量1与价格那些固化的标记2）对，要为欺骗感情辩别器，CGAN转换成器仅转换成以假乱真的统计资料并不是够的，转换成的子样表量量还须得与价格那些固化的标记相适配。在对转换成器实现宽裕训练法在此之后，就应该在传达所需要的的价格那些固化的标记来制定愿CGAN合出的子样表量量。

CGAN的生成器

利用噪声z和标签y合成一个为样本x*|y

CGAN的判别器

接受带标签的真实样本(x,y)，以及带有标签的伪样本(x*|y,y)，在真实样本-标签对上，鉴别器学习如何识别真实数据以及如何识别匹配对。在生成器生成的样本中，鉴别器学习识别伪样本-标签对，以将它们与真实样本-标签对区分开来。
判别器输出表明输入是真实的匹配对的概率，它的目标是学会接受所有的真实样本-标签对，并拒绝所有伪样本和所有与标签不匹配的样本。

架构图与汇总表

对于每个伪样本，相同的标签y同时被传递给生成器和鉴别器。另外，通过在带有不匹配标签的真实样本上训练鉴别器来拒绝不匹配的对；它识别不匹配对的能力是被训练成只接收真实匹配对时的副产品。

CGAN的实现

# 导入包
%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
from keras import backend as K
from tensorflow.keras.datasets import mnist
from keras.layers import Embedding, Multiply, Dropout, Lambda, Concatenate, Input, Dense, Flatten, Reshape, Activation, BatchNormalization
from keras.layers.advanced_activations import LeakyReLU
from keras.layers.convolutional import Conv2D, Conv2DTranspose
from keras.models import Sequential, Model
from keras.optimizers import Adam
from keras.utils import to_categorical

Using TensorFlow backend.

# 模型输入维度
img_rows = 28
img_cols = 28
channels = 1
# 图像大小
img_shape = (img_rows, img_cols, channels)
# 噪声向量大小
z_dim = 100

num_classes = 10

构造生成器

（1）运用Keras的Embedding层将tag标签y（0到9的整数）改变为的大小为z_dim（随意嗓声向量的长短）的稠密向量。 （2）实用Keras的Multiply层将标签纸与噪音污染向量z融入到聯合说道中。顾名思义，，该层将二个等长向量的对照项相乘，并所在用作没想到乘积的单独一个向量。 （3）将达到的向量最为投入，选择CGAN形成器在线的另一个一些以生成图相。

def build_generator(z_dim):
    model = Sequential()
    model.add(Dense(256 * 7 * 7, input_dim=z_dim))
    model.add(Reshape((7, 7, 256)))
    model.add(Conv2DTranspose(128, kernel_size=3, strides=2, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(64, kernel_size=3, strides=1, padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2DTranspose(1, kernel_size=3, strides=2, padding='same'))
    model.add(Activation('tanh'))
    return model

def build_cgan_genertator(z_dim):
    z = Input(shape=(z_dim, ))
    label = Input(shape=(1,), dtype='int32')
    label_embedding = Embedding(num_classes, z_dim, input_length=1)(label)
    label_embedding = Flatten()(label_embedding)
    
    joined_representation = Multiply()([z, label_embedding])
    
    generator = build_generator(z_dim)
    conditioned_img = generator(joined_representation)
    return Model([z, label], conditioned_img)

构造CGAN的判别器

步数： （1）取的商品性子（0到9的整数），选择Keras的Embedding层将商品性子会变成多少为28 × 28 × 1 = 784（扁型化数字图像的尺寸）的稠密向量。 （2）将放到tag标签调控为图像文件厚度（28 × 28 × 1）。 （3）将重新塑造后的融入性子接触到应对形象上，绘制样子（28 × 28× 2）的共同代表。是可以将其作出在顶端“贴有”融入性子的形象。 （4）将图案-元素的合力表达录入CGAN的鉴定器网络上中。小心，为了能够培养正常人来进行，可以将建模方法录入尺码的调整为（28 × 28 × 2）来相应新的录入造型。

def build_discriminator(img_shape):
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=(img_shape[0], img_shape[1], img_shape[2]+1),padding='same'))
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(64, kernel_size=3, strides=2, input_shape=img_shape,padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Conv2D(128, kernel_size=3, strides=2, input_shape=img_shape,padding='same'))
    model.add(BatchNormalization())
    model.add(LeakyReLU(alpha=0.01))
    model.add(Dropout(0.5))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

def build_cgan_discriminator(img_shape):
    img = Input(shape=img_shape)
    
    label = Input(shape=(1, ), dtype='int32')
    label_embedding = Embedding(num_classes, np.prod(img_shape), input_length=1)(label)
    label_embedding = Flatten()(label_embedding)
    label_embedding = Reshape(img_shape)(label_embedding) # 将标签调整和输入图像一样的维度
    concatenated = Concatenate(axis= -1)([img, label_embedding])# 将图像与其嵌入标签链接
    discriminator = build_discriminator(img_shape)
    classification = discriminator(concatenated)
    return Model([img, label], classification)

搭建整个模型

def build_cgan(generator, discriminator):
    z = Input(shape=(z_dim, ))
    label = Input(shape=(1, ))
    img = generator([z, label])
    classification = discriminator([img, label])
    model = Model([z, label], classification)
    return model

discriminator = build_cgan_discriminator(img_shape)
discriminator.compile(loss='binary_crossentropy', optimizer=Adam(), metrics=['accuracy'])
generator = build_cgan_genertator(z_dim)
discriminator.trainable = False

cgan = build_cgan(generator, discriminator)
cgan.compile(loss='binary_crossentropy', optimizer=Adam())

训练

losses = []
accuracies = []


def train(iterations, batch_size, sample_interval):
    (X_train, y_train), (_, _) = mnist.load_data('./MNIST')
    X_train = X_train / 127.5 - 1.0
    X_train = np.expand_dims(X_train, axis=3)
    real = np.ones((batch_size, 1))
    fake = np.zeros((batch_size, 1))
    
    for iteration in range(iterations):
        idx = np.random.randint(0, X_train.shape[0], batch_size)
#         print(X_train.shape[0])
        imgs, labels = X_train[idx], y_train[idx]
        z = np.random.normal(0, 1, (batch_size, z_dim))
        gen_imgs = generator.predict([z, labels])
#         print(imgs.shape)
        d_loss_real = discriminator.train_on_batch([imgs, labels], real)
        d_loss_fake = discriminator.train_on_batch([gen_imgs, labels], fake)
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
        
        z = np.random.normal(0, 1, (batch_size, z_dim))
        labels = np.random.randint(0, num_classes, batch_size).reshape(-1, 1)
        g_loss = cgan.train_on_batch([z, labels], real)
        if (iteration + 1) % sample_interval == 0:
            losses.append((d_loss[0], g_loss))
            accuracies.append(100.0 * d_loss[1])
            print("%d [D loss: %f, acc.: %.2f%%] [G loss:%f]"%(iteration + 1, d_loss[0], 100.0 * d_loss[1], g_loss))
            sample_images()

def sample_images (image_grid_rows=2, image_grid_columns=5):
    z = np.random.normal(0, 1, (image_grid_rows * image_grid_columns, z_dim))
    labels = np.arange(0, 10).reshape(-1, 1)
    gen_imgs = generator.predict([z, labels])
    gen_imgs = 0.5 * gen_imgs + 0.5
    fig, axs = plt.subplots(image_grid_rows,image_grid_columns,figsize=(10,4),sharey=True,sharex=True)
    cnt = 0
    for i in range(image_grid_rows):
        for j in range(image_grid_columns):
            axs[i,j].imshow(gen_imgs[cnt, :,:,0], cmap='gray')
            axs[i,j].axis('off')
            axs[i,j].set_title("Digit: %d" % labels[cnt])
            cnt +=1

iterations  = 12000
batch_size = 32
sample_interval = 1000
train(iterations, batch_size, sample_interval)

1000 [D loss: 0.000204, acc.: 100.00%] [G loss:9.885448]
2000 [D loss: 0.000059, acc.: 100.00%] [G loss:9.908726]
3000 [D loss: 0.230777, acc.: 90.62%] [G loss:4.183795]
4000 [D loss: 0.040735, acc.: 98.44%] [G loss:3.380749]
5000 [D loss: 0.192189, acc.: 90.62%] [G loss:3.410103]
6000 [D loss: 0.134279, acc.: 98.44%] [G loss:3.005539]
7000 [D loss: 0.412724, acc.: 82.81%] [G loss:1.312850]
8000 [D loss: 0.211682, acc.: 90.62%] [G loss:3.666016]
9000 [D loss: 0.080928, acc.: 98.44%] [G loss:7.182220]
10000 [D loss: 0.107635, acc.: 98.44%] [G loss:2.332113]
11000 [D loss: 0.194184, acc.: 93.75%] [G loss:3.737709]
12000 [D loss: 0.191671, acc.: 89.06%] [G loss:4.127837]

培养1000次

训练6000次

训练1200次

小结

CGAN进行了不只是添加有些相似于的确样表甚至还得添加其中一个遵循环境的实际存在样表。用增高添加器判别器的发送进一个步骤增进了GAN的职能。 Github详细地址：//github.com/yunlong-G/tensorflow_learn/blob/master/GAN/CGAN.ipynb