GENs生成对抗神经网络demo实例

import tensorflow as tf
from tensorflow.keras import layers
import numpy as np
import matplotlib.pyplot as plt

# 设置随机种子以便结果可重复
tf.random.set_seed(42)
np.random.seed(42)

# 定义生成器模型
def build_generator(input_shape):
    model = tf.keras.Sequential([
        layers.Dense(256, input_shape=input_shape, activation='relu'),
        layers.Dense(512, activation='relu'),
        layers.Dense(1024, activation='relu'),
        layers.Dense(784, activation='sigmoid'),
        layers.Reshape((28, 28, 1))
    ])
    return model

# 定义判别器模型
def build_discriminator(input_shape):
    model = tf.keras.Sequential([
        layers.Flatten(input_shape=input_shape),
        layers.Dense(1024, activation='relu'),
        layers.Dense(512, activation='relu'),
        layers.Dense(256, activation='relu'),
        layers.Dense(1, activation='sigmoid')
    ])
    return model

# 定义GAN模型
def build_gan(generator, discriminator):
    discriminator.trainable = False
    model = tf.keras.Sequential([generator, discriminator])
    return model

# 创建生成器、判别器和GAN模型
generator = build_generator((100,))
discriminator = build_discriminator((28, 28, 1))
gan = build_gan(generator, discriminator)

# 定义优化器和损失函数
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
loss_fn = tf.keras.losses.BinaryCrossentropy()

# 准备虚拟的数据集（这里仅作示例，实际应该使用真实数据集）
real_images = tf.random.normal([128, 28, 28, 1])
real_labels = tf.ones((128, 1))  # Real images are labeled as 1
fake_labels = tf.zeros((128, 1))  # Fake images are labeled as 0

# 训练模型
def train(generator, discriminator, gan, epochs, display_interval):
    for epoch in range(epochs):
        # 随机噪声
        noise = tf.random.normal([128, 100])

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

            real_output = discriminator(real_images, training=True)
            fake_output = discriminator(generated_images, training=True)

            # 判别器损失
            disc_loss_real = loss_fn(real_labels, real_output)
            disc_loss_fake = loss_fn(fake_labels, fake_output)
            disc_loss = (disc_loss_real + disc_loss_fake) / 2

            # 生成器损失
            gen_loss = loss_fn(real_labels, fake_output)

        # 梯度更新
        gradients_of_discriminator = disc_tape.gradient(disc_loss, discriminator.trainable_variables)
        gradients_of_generator = gen_tape.gradient(gen_loss, generator.trainable_variables)

        optimizer.apply_gradients(zip(gradients_of_discriminator, discriminator.trainable_variables))
        optimizer.apply_gradients(zip(gradients_of_generator, generator.trainable_variables))

        # 每100轮后显示生成的图像
        if (epoch + 1) % 100 == 0 or epoch == 0:
            print(f'Epoch {epoch + 1}, Generator Loss: {gen_loss.numpy()}, Discriminator Loss: {disc_loss.numpy()}')
            show_images(generator)

def show_images(generator, num_images=5):
    noise = tf.random.normal([num_images, 100])
    generated_images = generator(noise, training=False)
    generated_images = (generated_images * 255).numpy().astype(np.uint8)
    fig, axes = plt.subplots(1, num_images, figsize=(10, 2))
    for img, ax in zip(generated_images, axes):
        ax.imshow(img.squeeze(), cmap='gray')
        ax.axis('off')
    plt.show()

# 训练模型
train(generator, discriminator, gan, 500, 100)