人们如今热衷于深入学习研究。结果，每天或每月都会发布新模型或新概念的新技术或体系结构。其中一项值得注意的工作是由OpenAI的Ian Goodfellow et.al在2014年发表的“Generative Adversarial Networks”。它是最酷的神经网络架构之一。

生成模型和判别模型

有两种广泛类型的机器学习模型，a。）判别模型 b。）生成模型。

在判别模型中，算法试图将输入映射到输出，但他们不关心数据中的潜在变量。他们忽视数据的表示。在数学术语中，生成模型学习条件概率分布。

联合概率分布

然而，在生成模型中，算法尝试将输入映射到输出，并且还学习潜在变量和数据表示。因此，生成模型学习数据的联合概率分布。通过使用这个，我们可以从学习数据中生成新的数据点。GAN是生成模型。

对抗游戏

对抗游戏是人工智能(AI)的领域，两个或更多的代理相互作用，试图通过完成目标打败对手。最常见的例子之一是zero-sum 游戏，如井字棋或跳棋。一个玩家最大化，另一个最小化，因此他们玩的是min-max游戏(根据博弈论)。

GAN有两个神经网络，一个是判别网络，另一个是生成网络。每个网络互相尝试，从而在整个过程中通过生成网络学习数据的表示。因此就有了“对抗网络”这个词。

网络背后的数学

深度学习或机器学习都是为了优化函数或最小化算法的损失。我们用梯度下降法。

设X为真实数据集，Z为正态分布噪声。设p(z)为潜在空间z的数据，G和D分别是生成网络和判别网络的可微函数。D(x)表示数据来自真实数据集x的概率，我们训练D使概率日志(D(x)最大化，训练G使日志(1 – D(G(z))最小化。简而言之，他们玩的是上面介绍的最小最大值游戏，并获得全局最优性。

GAN（损失函数）

以上函数为我们的生成对抗网络提供了损失函数。现在，注意log（1 – D（G（z））饱和是很重要的，所以我们不会使它最小化，而是我们最大化log（D（G（z）））。

为了证明由发生器网络生成的样本与X完全相同，我们需要深入数学，并使用Kullback-Leibler散度定理和Jensen-Shannon散度。

生成对抗网络的训练是非常困难的。为了成功地训练它们，需要记住一些关键点。

网络架构

为了简化，我们使用前馈神经网络作为原始建立一个网络。这将是我们的生成网络，它将从潜在的样本空间Z中获取输入。该网络的输出维度将与原始样本数据中的特征数量相同。我们建立了另一个充当判别器的网络。它将只输出一个标量值。

对于这种情况，我们将生成MNIST数字的图像。

以下是简要的网络规范 ：

• 生成网络[n，m]的输入层，其中n是样本数，m是潜变量的维数。这里，n = 128，m = 100。
• 它将有两个隐藏层，后跟输出层。[100,256] => [256,512]
• 输出层[512,768]
• 判别网络输入层由权重[128,768]组成
• 两个隐藏层有[768,512] => [512,256]
• 最后输出层[256,1]。

Training GAN

Tensorflow实现

在本节中，我们必须具备一些关于张量流的基本知识。我将仅解释损失函数计算部分，该区域在实现中是棘手的。Python实现如下：

from datetime import datetime

import argparse

import tensorflow as tf

import numpy as np

import matplotlib.pyplot as plt

import matplotlib.gridspec as gridspec

BATCH_SIZE = 128

LEARNING_RATE = 1e-3

EPOCHS = 75

Z_DIM = 100

def he_xavier(in_size: int, out_size: int, init_only=False):

“””

Xavier initialization according to Kaiming He in:

*Delving Deep into Rectifiers: Surpassing Human-Level

Performance on ImageNet Classification

(https://arxiv.org/abs/1502.01852)

“””

stddev = tf.cast(tf.sqrt(2 / in_size), tf.float32)

W = tf.random_normal([in_size, out_size], stddev=stddev)

b = tf.zeros([out_size])

if init_only:

return W, b

return tf.Variable(W, name=”weights”), tf.Variable(b, name=”biases”)

def print_flags(flags):

for key, value in vars(flags).items():

print(“{}: {}”.format(key, str(value)))

def load_mnist():

from tensorflow.examples.tutorials.mnist import input_data

return input_data.read_data_sets(“./MNIST_data”, one_hot=True)

class GAN(object):

def __init__(self, lr=1E-3, batch_size=128, z_dim=100):

self.lr = lr

self.batch_size = batch_size

self.z_dim = z_dim

self.z_in = tf.placeholder(tf.float32, shape=[None, z_dim])

self.x_in = tf.placeholder(tf.float32, shape=[None, 784])

# Construct Discriminator/ Generator graph ops

self.g_sample, self.g_weights = self.generator(z=self.z_in)

self.d_real, self.d_weights = self.discriminator(self.x_in)

self.d_fake, _ = self.discriminator(self.g_sample, reuse=True)

# Loss and optimization ops

self.d_loss, self.g_loss = self.loss()

self.d_train, self.g_train = self.optimize()

# Initialize session to run ops in

self._sess = tf.Session()

self._sess.run(tf.initialize_all_variables())

def discriminator(self, x, reuse=False):

with tf.variable_scope(“D”, reuse=reuse):

W1_init, _ = he_xavier(784, 128, init_only=True)

W1 = tf.get_variable(“W1”, initializer=W1_init)

b1 = tf.get_variable(“b1”, shape=[128], initializer=tf.constant_initializer(0.0))

d_h1 = tf.nn.elu(tf.add(tf.matmul(x, W1), b1))

W2_init, _ = he_xavier(128, 1, init_only=True)

W2 = tf.get_variable(“W2”, initializer=W2_init)

b2 = tf.get_variable(“b2”, shape=[1], initializer=tf.constant_initializer(0.0))

d_h2 = tf.add(tf.matmul(d_h1, W2), b2)

return tf.nn.sigmoid(d_h2), [W1,b1,W2,b2]

def generator(self, z):

W1, b1 = he_xavier(self.z_dim, 128)

g_h1 = tf.nn.elu(tf.add(tf.matmul(z, W1), b1))

W2, b2 = he_xavier(128, 784)

g_h2 = tf.add(tf.matmul(g_h1, W2), b2)

return tf.nn.sigmoid(g_h2), [W1,b1,W2,b2]

def loss(self):

discriminator_loss = -tf.reduce_mean(tf.log(self.d_real) + tf.log(1. – self.d_fake))

generator_loss = -tf.reduce_mean(tf.log(self.d_fake))

return discriminator_loss, generator_loss

def optimize(self):

optimizer = tf.train.AdamOptimizer(learning_rate=self.lr)

d_train = optimizer.minimize(self.d_loss, var_list=self.d_weights)

g_train = optimizer.minimize(self.g_loss, var_list=self.g_weights)

return d_train, g_train

def sample_z(self, num_samples):

return np.random.uniform(-1., 1., size=[num_samples, self.z_dim])

def train_discriminator(self, x_in):

z_sample = self.sample_z(self.batch_size)

fetches = [self.d_train, self.d_loss]

_, d_loss = self._sess.run(fetches, feed_dict={self.x_in: x_in, self.z_in:z_sample})

return d_loss

def train_generator(self):

z_sample = self.sample_z(self.batch_size)

fetches = [self.g_train, self.g_loss]

_, g_loss = self._sess.run(fetches, feed_dict={self.z_in: z_sample})

return g_loss

def sample_g(self, num_samples):

z_sample = self.sample_z(num_samples=num_samples)

return self._sess.run(self.g_sample, feed_dict={self.z_in: z_sample})

def plot_grid(samples):

fig = plt.figure(figsize=(4, 4))

gs = gridspec.GridSpec(4, 4)

gs.update(wspace=0.05, hspace=0.05)

for i, sample in enumerate(samples):

ax = plt.subplot(gs[i])

plt.axis(‘off’)

ax.set_xticklabels([])

ax.set_yticklabels([])

ax.set_aspect(‘equal’)

plt.imshow(sample.reshape(28, 28), cmap=’Greys_r’)

return fig

def main(_):

print_flags(FLAGS)

gan = GAN(lr=FLAGS.learning_rate, batch_size=FLAGS.batch_size, z_dim=FLAGS.z_dim)

mnist = load_mnist()

print(“Started training {}”.format(datetime.now().isoformat()[11:]))

plot_index = 0

for epoch in range(FLAGS.epochs):

for batch in range(mnist.train.num_examples // FLAGS.batch_size):

batch_x, _ = mnist.train.next_batch(FLAGS.batch_size)

_ = gan.train_discriminator(x_in=batch_x) # train disciminator

_ = gan.train_generator() # train generator

if epoch % 10 == 0:

d_loss = gan.train_discriminator(x_in=batch_x)

g_loss = gan.train_generator()

print(“Epoch {} Discriminator Loss {} Generator loss {}”.format(epoch + 1,

d_loss,

g_loss))

gen_sample = gan.sample_g(num_samples=16)

fig = plot_grid(gen_sample)

plt.savefig(‘{}.png’.format(str(plot_index).zfill(3)), bbox_inches=’tight’)

plot_index += 1

plt.close(fig)

print(“Ended training {}”.format(datetime.now().isoformat()[11:]))

FLAGS = None

if __name__ == “__main__”:

parser = argparse.ArgumentParser()

parser.add_argument(“–learning_rate”, type=int, default=LEARNING_RATE)

parser.add_argument(“–batch_size”, type=int, default=BATCH_SIZE)

parser.add_argument(“–epochs”, type=int, default=EPOCHS)

parser.add_argument(“–z_dim”, type=int, default=Z_DIM)

FLAGS, _ = parser.parse_known_args()

tf.app.run()

我们首先用真实数据训练discriminator ，然后我们训练generator，给discriminator 提供假图像。在上面我们的讨论中，我们需要最大化方程，但是tensroflow只有最小化，所以负号才能做到这一点。在第85行中，只使用log(D(G(z))，如前面讨论的原始方程饱和。

GAN生成的示例图像

结论

GAN是最先进的神经网络之一，可以用来做很多事情。我们可以将它用于某些我们目前没有医疗处理的疾病的药物发现。压缩数据然后解压缩数据。恢复损坏的数据，文本到图像生成，以及更多无穷无尽的应用程序生成对抗网络。