CGAN_MNIST示例

原始GAN的缺点：

生成的图像是随机的，不可预测的，无法控制网络输出特定的图片，生成目标不明确，可控性不强针对原始GAN不能生成具有特定属性的图片的问题，Mehdi Mirza等人提出了cGAN，其核心在于将属性信息y，融入生成器G和判别器D中，属性y可以是任何标签信息，例如图像的类别、人脸图像的面部表情等。

CGAN的网络模型

import tensorflow as tf
import pandas as pd
import numpy as np
from tensorflow import keras
import matplotlib.pyplot as plt
import os
from  sklearn.preprocessing import MinMaxScaler

# 载入数据
(x_train_all, y_train_all), (x_test, y_test) = keras.datasets.mnist.load_data()

# 划分数据集
x_train, x_valid = x_train_all[5000:], x_train_all[:5000]
y_train, y_valid = y_train_all[5000:], y_train_all[:5000]

# 进行归一化
scaler = MinMaxScaler()
x_train_scaled = scaler.fit_transform(x_train.astype(np.float32).reshape(-1, 1)).reshape(-1, 28, 28, 1)

# 进行数据封装
train_datasets = tf.data.Dataset.from_tensor_slices((x_train_scaled, y_train))
train_datasets = train_datasets.shuffle(x_train_scaled.shape[0]).batch(64)

# print(train_datasets)

BATCH_SIZE = 256
image_count = x_train_scaled.shape[0]
# print(image_count)
noise_dim = 50


# 定义生产者模型
def generator_model():
    seed = keras.layers.Input(shape=(noise_dim,))
    label = keras.layers.Input(shape=(()))

    x = keras.layers.Embedding(10, 50, input_length=1)(label)
    x = keras.layers.Flatten()(x)
    x = keras.layers.concatenate([seed, x])  # (None, 100)

    x = keras.layers.Dense(3 * 3 * 128, use_bias=False)(x)
    x = keras.layers.Reshape((3, 3, 128))(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.ReLU()(x)  # (None, 3, 3, 128)

    x = keras.layers.Conv2DTranspose(64, 3, strides=(2, 2), use_bias=False)(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.ReLU()(x)  # (None, 7, 7, 64)

    x = keras.layers.Conv2DTranspose(32, 3, strides=(2, 2), use_bias=False, padding='same')(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.ReLU()(x)  # (None, 14, 14, 32)

    x = keras.layers.Conv2DTranspose(1, 3, strides=(2, 2), use_bias=False, padding='same')(x)
    x = keras.layers.Activation('tanh')(x)  # (None, 28, 28, 1)

    model = keras.models.Model(inputs=[seed, label], outputs=x)
    return model


generator = generator_model()


# print(generator.summary())


# 定义判别器模型
def discriminator_model():
    image = keras.layers.Input(shape=((28, 28, 1)))
    label = keras.layers.Input(shape=(()))

    x = keras.layers.Embedding(10, 28 * 28, input_length=1)(label)
    x = keras.layers.Reshape((28, 28, 1))(x)
    x = keras.layers.concatenate([image, x])  # (None, 28, 28, 2)

    x = keras.layers.Conv2D(32, 3, strides=(2, 2), padding='same', use_bias=False)(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.LeakyReLU()(x)
    x = keras.layers.Dropout(0.5)(x)  # (None, 14, 14, 32)

    x = keras.layers.Conv2D(64, 3, strides=(2, 2), padding='same', use_bias=False)(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.LeakyReLU()(x)
    x = keras.layers.Dropout(0.5)(x)  # (None, 7, 7, 64)

    x = keras.layers.Conv2D(128, 3, strides=(2, 2), padding='same', use_bias=False)(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.LeakyReLU()(x)
    x = keras.layers.Dropout(0.5)(x)  # (None, 4, 4, 128)

    x = keras.layers.Flatten()(x)
    x = keras.layers.Dense(1)(x)  # (None, 1)
    model = keras.models.Model(inputs=[image, label], outputs=x)
    return model


discriminator = discriminator_model()
# print(discriminator.summary())

# 定义损失函数
binary_cross_entropy = tf.losses.BinaryCrossentropy(from_logits=False)


# 定义判别器损失函数
def discriminator_loss(real_output, fake_output):
    return binary_cross_entropy(tf.ones_like(real_output), real_output) + binary_cross_entropy(
        tf.zeros_like(fake_output), fake_output)


# 定义生成器损失函数
def generator_loss(fake_output):
    return binary_cross_entropy(tf.ones_like(fake_output), fake_output)


# 定义优化器
generator_optimizers = tf.keras.optimizers.Adam(1e-5)
discriminator_optimizers = tf.keras.optimizers.Adam(1e-5)


# 定义迭代训练
@tf.function
def train_step(images, labels):
    noise = tf.random.normal([labels.shape[0], noise_dim])  # (64,50)

    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        gen_image = generator((noise, labels), training=True)

        fake_output = discriminator((gen_image, labels), training=True)
        real_output = discriminator((images, labels), training=True)

        # 求损失
        gen_loss = generator_loss(fake_output)
        disc_loss = discriminator_loss(real_output, fake_output)

    # 根据损失求梯度
    gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)
    gradients_of_disciminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)

    # 进行梯度优化
    generator_optimizers.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    discriminator_optimizers.apply_gradients(zip(gradients_of_disciminator, discriminator.trainable_variables))


def showImg(generator_model, noise, label, epoch):
    pred = generator_model((noise, label), training=False)
    # print(pred.shape)  # (10, 28, 28, 1)
    pred = tf.squeeze(pred)

    plt.figure(figsize=(10, 1))

    for i in range(pred.shape[0]):
        plt.subplot(1, 10, i + 1)
        plt.imshow(pred[i, :, :])
        plt.axis('off')

    plt.savefig('image_of_epoch{:04d}.png'.format(epoch))
    plt.show()


EPOCHS = 10
noise_seed = tf.random.normal([10, noise_dim])  # (10,50)
label_seed = np.random.randint(0, 10, size=(10, 1))  # (10,)
print(label_seed.T)


def train(traindatasets, epochs):
    for epoch in range(epochs):
        for image, label in traindatasets:
            train_step(image, label)
            print('.', end='')
        print()
        # showImg(generator, noise_seed, label_seed, epoch + 1)

    showImg(generator, noise_seed, label_seed, epochs)


train(train_datasets, EPOCHS)


num = 10
noise_seed_test = tf.random.normal([num, noise_dim])
cat_seed_test = np.arange(10).reshape(-1, 1)
print(cat_seed_test.T)

showImg(generator, noise_seed_test, cat_seed_test, 1)