DCGAN的基本实现示例-手写数字识别

DCGAN基本示例-手写数字识别

DCGAN原理分析

什么是DCGAN?
DCGAN就是将CNN和原始的GAN结合到了一起，生成模型和判别模型都运用了深度卷积神经网络的生成对抗网络。

模型结构图：

代码实现

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

# 载入数据
(x_train_all, y_train_all), (_, _) = 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)
# print(x_train_scaled.shape)

# 封装数据集
train_datasets = tf.data.Dataset.from_tensor_slices(x_train_scaled)
train_datasets = train_datasets.shuffle(x_train_scaled.shape[0]).batch(128)


# print(train_datasets)

# 建立模型
def generator_model():
    model = keras.Sequential()
    model.add(keras.layers.Dense(7 * 7 * 256, input_shape=(100,), use_bias=False))
    model.add(keras.layers.BatchNormalization())
    model.add(keras.layers.LeakyReLU())

    model.add(keras.layers.Reshape((7, 7, 256)))

    model.add(keras.layers.Conv2DTranspose(128, 5, strides=(1, 1), use_bias=False, padding='same'))
    model.add(keras.layers.BatchNormalization())
    model.add(keras.layers.LeakyReLU())

    model.add(keras.layers.Conv2DTranspose(64, 5, strides=(2, 2), use_bias=False, padding='same'))
    model.add(keras.layers.BatchNormalization())
    model.add(keras.layers.LeakyReLU())

    model.add(keras.layers.Conv2DTranspose(1, 5, strides=(2, 2), use_bias=False, padding='same'))

    return model


generator = generator_model()


# 定义判别器模型
def discrimintator_model():
    model = keras.Sequential()
    model.add(keras.layers.Conv2D(64, 5, strides=(2, 2), padding='same', input_shape=([28, 28, 1])))
    model.add(keras.layers.LeakyReLU())
    model.add(keras.layers.Dropout(0.3))

    model.add(keras.layers.Conv2D(128, 5, strides=(2, 2), padding='same'))
    model.add(keras.layers.LeakyReLU())
    model.add(keras.layers.Dropout(0.3))

    model.add(keras.layers.Flatten())
    model.add(keras.layers.Dense(1))

    return model


discrimintator = discrimintator_model()
# print(discrimintator.summary())

# 定义损失函数
cross_entropy = tf.losses.BinaryCrossentropy(from_logits=True)


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


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


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

BATCHS = 128
EPOCHS = 50

num_example_to_generate = 16
noise_dim = 100

seed = tf.random.normal([num_example_to_generate, noise_dim])


# 迭代训练
@tf.function
def train_step(images):
    noise = tf.random.normal([num_example_to_generate, noise_dim])
    with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:
        gen_images = generator(noise, training=True)

        real_output = discrimintator(images, training=True)
        fake_output = discrimintator(gen_images, 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, discrimintator.trainable_variables)

    # 进行梯度优化
    generator_optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))
    discrimintator_optimizer.apply_gradients(zip(gradients_of_disciminator, discrimintator.trainable_variables))


def showImg(generator_model, epoch, noise):
    pred = generator_model(noise)
    plt.figure(figsize=(4, 4))

    for i in range(pred.shape[0]):
        plt.subplot(4, 4, i + 1)
        plt.imshow(pred[i].numpy().reshape(28, 28), cmap='gray')
        plt.axis('off')

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


def train(traindatasets, epochs):
    for epoch in range(epochs):
        for image_batch in traindatasets:
            train_step(image_batch)
            print('.', end='')
        print()

        showImg(generator, epoch + 1, seed)

    showImg(generator, epochs, seed)


train(train_datasets, EPOCHS)