大家都知道，自從生成式對抗網絡（GAN）出現以來，便在圖像處理方面有著廣泛的應用。但還是有很多人對于GAN不是很了解，擔心由于沒有數學知識底蘊而學不會GAN。在本文中，谷歌研究員Stefan Hosein提供了一份初學者入門GAN的教程，在這份教程中，即使你沒有擁有深厚的數學知識，你也能夠了解什么是生成式對抗網絡（GAN）。

類比

理解GAN的一個最為簡單的方法是通過一個簡單的比喻：

假設有一家商店，店主要從顧客那里購買某些種類的葡萄酒，然后再將這些葡萄酒銷售出去。

然而，有些可惡的顧客為了賺取金錢而出售假酒。在這種情況下，店主必須能夠區分假酒和正宗的葡萄酒。

你可以想象，在最初的時候，偽造者在試圖出售假酒時可能會犯很多錯誤，并且店主很容易就會發現該酒不是正宗的葡萄酒。經歷過這些失敗之后，偽造者會繼續嘗試使用不同的技術來模擬真正的葡萄酒，而有些方法最終會取得成功。現在，偽造者知道某些技術已經能夠躲過店主的檢查，那么他就可以開始進一步對基于這些技術的假酒進行改善提升。

與此同時，店主可能會從其他店主或葡萄酒專家那里得到一些反饋，說明她所擁有的一些葡萄酒并不是原裝的。這意味著店主必須改進她的判別方式，從而確定葡萄酒是偽造的還是正宗的。偽造者的目標是制造出與正宗葡萄酒無法區分的葡萄酒，而店主的目標是準確地分辨葡萄酒是否是正宗的。

可以這樣說，這種循環往復的競爭正是GAN背后的主要思想。

生成式對抗網絡的組成部分

通過上面的例子，我們可以提出一個GAN的體系結構。

GAN中有兩個主要的組成部分：生成器和鑒別器。在上面我們所描述的例子中，店主被稱為鑒別器網絡，通常是一個卷積神經網絡（因為GAN主要用于圖像任務），主要是分配圖像是真實的概率。

偽造者被稱為生成式網絡，并且通常也是一個卷積神經網絡（具有解卷積層，deconvolution layers）。該網絡接收一些噪聲向量并輸出一個圖像。當對生成式網絡進行訓練時，它會學習可以對圖像的哪些區域進行改進/更改，以便鑒別器將難以將其生成的圖像與真實圖像區分開來。

生成式網絡不斷地生成與真實圖像更為接近的圖像，而與此同時，鑒別式網絡則試圖確定真實圖像和假圖像之間的差異。最終的目標就是建立一個生成式網絡，它可以生成與真實圖像無法區分的圖像。

用Keras編寫一個簡單的生成式對抗網絡

現在，你已經了解什么是GAN，以及它們的主要組成部分，那么現在我們可以開始試著編寫一個非常簡單的代碼。你可以使用Keras，如果你不熟悉這個Python庫的話，則應在繼續進行操作之前閱讀本教程。本教程基于易于理解的GAN進行開發的。

首先，你需要做的第一件事是通過pip安裝以下軟件包：

- keras

- matplotlib

- tensorflow

- tqdm

你將使用matplotlib繪圖，tensorflow作為Keras后端庫和tqdm，以顯示每個輪數（迭代）的花式進度條。

下一步是創建一個Python腳本，在這個腳本中，你首先需要導入你將要使用的所有模塊和函數。在使用它們時將給出每個解釋。

importos

import numpy as np

import matplotlib.pyplot as plt

from tqdm import tqdm

from keras.layers import Input

from keras.models import Model, Sequential

from keras.layers.core import Dense, Dropout

from keras.layers.advanced_activations import LeakyReLU

from keras.datasets import mnist

from keras.optimizers import Adam

from keras import initializers

你現在需要設置一些變量：

# Let Keras know that we are using tensorflow as our backend engine

os.environ["KERAS_BACKEND"] = "tensorflow"

# To make sure that we can reproduce the experiment and get the same results

np.random.seed(10)

# The dimension of our random noise vector.

random_dim = 100

在開始構建鑒別器和生成器之前，你首先應該收集數據，并對其進行預處理。你將會使用到常見的MNIST數據集，該數據集具有一組從0到9的單個數字圖像。

MINST數字樣本

def load_minst_data():

# load the data

(x_train, y_train), (x_test, y_test) = mnist.load_data()

# normalize our inputs to be in the range[-1, 1]

x_train = (x_train.astype(np.float32) - 127.5)/127.5

# convert x_train with a shape of (60000, 28, 28) to (60000, 784) so we have

# 784 columns per row

x_train = x_train.reshape(60000, 784)

return (x_train, y_train, x_test, y_test)

需要注意的是，mnist.load_data()是Keras的一部分，這使得你可以輕松地將MNIST數據集導入至工作區域中。

現在，你可以開始創建你的生成器和鑒別器網絡了。在這一過程中，你會使用到Adam優化器。此外，你還需要創建一個帶有三個隱藏層的神經網絡，其激活函數為Leaky Relu。對于鑒別器而言，你需要為其添加dropout層（dropout layers），以提高對未知圖像的魯棒性。

def get_optimizer():

return Adam(lr=0.0002, beta_1=0.5)

def get_generator(optimizer):

generator = Sequential()

generator.add(Dense(256, input_dim=random_dim, kernel_initializer=initializers.RandomNormal(stddev=0.02)))

generator.add(LeakyReLU(0.2))

generator.add(Dense(512))

generator.add(LeakyReLU(0.2))

generator.add(Dense(1024))

generator.add(LeakyReLU(0.2))

generator.add(Dense(784, activation='tanh'))

generator.compile(loss='binary_crossentropy', optimizer=optimizer)

return generator

def get_discriminator(optimizer):

discriminator = Sequential()

discriminator.add(Dense(1024, input_dim=784, kernel_initializer=initializers.RandomNormal(stddev=0.02)))

discriminator.add(LeakyReLU(0.2))

discriminator.add(Dropout(0.3))

discriminator.add(Dense(512))

discriminator.add(LeakyReLU(0.2))

discriminator.add(Dropout(0.3))

discriminator.add(Dense(256))

discriminator.add(LeakyReLU(0.2))

discriminator.add(Dropout(0.3))

discriminator.add(Dense(1, activation='sigmoid'))

discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)

return discriminator

接下來，則需要將發生器和鑒別器組合在一起！

def get_gan_network(discriminator, random_dim, generator, optimizer):

# We initially set trainable to False since we only want to train either the

# generator or discriminator at a time

discriminator.trainable = False

# gan input (noise) will be 100-dimensional vectors

gan_input = Input(shape=(random_dim,))

# the output of the generator (an image)

x = generator(gan_input)

# get the output of the discriminator (probability if the image is real or not)

gan_output = discriminator(x)

gan = Model(inputs=gan_input, outputs=gan_output)

gan.compile(loss='binary_crossentropy', optimizer=optimizer)

return gan

為了完整起見，你還可以創建一個函數，使其每訓練20個輪數就對生成的圖像進行1次保存。由于這不是本次課程的核心內容，因此你不必完全理解該函數。

def plot_generated_images(epoch, generator, examples=100, dim=(10, 10), figsize=(10, 10)):

noise = np.random.normal(0, 1, size=[examples, random_dim])

generated_images = generator.predict(noise)

generated_images = generated_images.reshape(examples, 28, 28)

plt.figure(figsize=figsize)

for i in range(generated_images.shape[0]):

plt.subplot(dim[0], dim[1], i+1)

plt.imshow(generated_images[i], interpolation='nearest', cmap='gray_r')

plt.axis('off')

plt.tight_layout()

plt.savefig('gan_generated_image_epoch_%d.png' % epoch)

你現在已經編碼了大部分網絡，剩下的就是訓練這個網絡，并查看你創建的圖像。

def train(epochs=1, batch_size=128):

# Get the training and testing data

x_train, y_train, x_test, y_test = load_minst_data()

# Split the training data into batches of size 128

batch_count = x_train.shape[0] / batch_size

# Build our GAN netowrk

adam = get_optimizer()

generator = get_generator(adam)

discriminator = get_discriminator(adam)

gan = get_gan_network(discriminator, random_dim, generator, adam)

for e in xrange(1, epochs+1):

print '-'*15, 'Epoch %d' % e, '-'*15

for _ in tqdm(xrange(batch_count)):

# Get a random set of input noise and images

noise = np.random.normal(0, 1, size=[batch_size, random_dim])

image_batch = x_train[np.random.randint(0, x_train.shape[0], size=batch_size)]

# Generate fake MNIST images

generated_images = generator.predict(noise)

X = np.concatenate([image_batch, generated_images])

# Labels for generated and real data

y_dis = np.zeros(2*batch_size)

# One-sided label smoothing

y_dis[:batch_size] = 0.9

# Train discriminator

discriminator.trainable = True

discriminator.train_on_batch(X, y_dis)

# Train generator

noise = np.random.normal(0, 1, size=[batch_size, random_dim])

y_gen = np.ones(batch_size)

discriminator.trainable = False

gan.train_on_batch(noise, y_gen)

if e == 1 or e % 20 == 0:

plot_generated_images(e, generator)

if __name__ == '__main__':

train(400, 128)

在訓練400個輪數后，你可以查看生成的圖像。在查看經過1個輪數訓練后而生成的圖像時，你會發現它沒有任何真實結構，在查看經過40個輪數訓練后而生成的圖像時，你會發現數字開始成形，最后，在查看經過400個輪數訓練后而生成的圖像時，你會發現，除了一組數字難以辨識外，其余大多數數字都清晰可見。

訓練1個輪數后的結果（上）| 訓練40個輪數后的結果（中） | 訓練400個輪數后的結果（下）

此代碼在CPU上運行一次大約需要2分鐘，這也是我們選擇該代碼的主要原因。你可以嘗試進行更多輪數的訓練，并向生成器和鑒別器中添加更多數量（種類）的層。當然，在僅使用CPU的前提下，采用更復雜和更深層的體系結構時，相應的代碼運行時間也會有所延長。但也不要因此放棄嘗試。

至此，你已經完成了全部的學習任務，你以一種直觀的方式學習了生成式對抗網絡（GAN）的基礎知識！并且，你還在Keras庫的協助下實現了你的第一個模型。