notebook定义gan网络

GAN（Generative Adversarial Network，生成对抗网络）是一种深度学习的无监督学习模型，用于生成类似于训练数据的新数据。GAN由生成器（Generator）和判别器（Discriminator）组成，两者通过对抗的方式进行训练。

在Notebook中定义GAN网络可以分为以下步骤：

1.导入必要的包

import keras
from keras.models import Sequential, Model
from keras.layers import Dense, Activation, Flatten, Reshape, Input
from keras.layers.convolutional import Conv2D, Conv2DTranspose
from keras.layers.normalization import BatchNormalization
from keras.layers.advanced_activations import LeakyReLU
from keras.optimizers import Adam

2.定义生成器模型

def generator():
    model = Sequential()
    model.add(Dense(256, input_dim=100))
    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(28*28*1, activation='tanh'))
    model.add(Reshape((28, 28, 1)))
    return model

3.定义判别器模型

def discriminator():
    model = Sequential()
    model.add(Conv2D(32, kernel_size=3, strides=2, input_shape=(28, 28, 1), padding='same'))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Conv2D(64, kernel_size=3, strides=2, padding='same'))
    model.add(BatchNormalization(momentum=0.8))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Conv2D(128, kernel_size=3, strides=2, padding='same'))
    model.add(BatchNormalization(momentum=0.8))
    model.add(LeakyReLU(alpha=0.2))
    model.add(Flatten())
    model.add(Dense(1, activation='sigmoid'))
    return model

4.编译GAN模型

def gan(generator, discriminator):
    discriminator.trainable = False
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    model.compile(loss='binary_crossentropy', optimizer=Adam(lr=0.0002, beta_1=0.5))
    return model

5.训练GAN模型

def train(generator, discriminator, gan, X_train, epochs=5000, batch_size=32, sample_interval=50):
    for epoch in range(epochs):

        # ---------------------
        #  Train Discriminator
        # ---------------------

        # Select a random batch of images
        idx = np.random.randint(0, X_train.shape[0], batch_size)
        real_imgs = X_train[idx]

        # Generate a batch of fake images
        noise = np.random.normal(0, 1, (batch_size, 100))
        fake_imgs = generator.predict(noise)

        # Train the discriminator
        d_loss_real = discriminator.train_on_batch(real_imgs, np.ones((batch_size, 1)))
        d_loss_fake = discriminator.train_on_batch(fake_imgs, np.zeros((batch_size, 1)))
        d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)

        # ---------------------
        #  Train Generator
        # ---------------------

        # Generate a batch of images
        noise = np.random.normal(0, 1, (batch_size, 100))

        # Train the generator
        g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))

        # Plot the progress
        if epoch % sample_interval == 0:
            print("Epoch %d [D loss: %f] [G loss: %f]" % (epoch, d_loss, g_loss))

在这个例子中，生成器和判别器都是使用Keras建立的神经网络模型，GAN模型使用生成器和判别器组合在一起训练。在训练过程中，生成器生成假数据，并尝试欺骗判别器，而判别器则尝试将假数据与真实数据分开。通过不断迭代训练，GAN模型可以生成非常逼真的假数据。