大家好,欢迎来到IT知识分享网。
人们如今热衷于深入学习研究。结果,每天或每月都会发布新模型或新概念的新技术或体系结构。其中一项值得注意的工作是由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))最小化。简而言之,他们玩的是上面介绍的最小最大值游戏,并获得全局最优性。
以上函数为我们的生成对抗网络提供了损失函数。现在,注意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]。
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是最先进的神经网络之一,可以用来做很多事情。我们可以将它用于某些我们目前没有医疗处理的疾病的药物发现。压缩数据然后解压缩数据。恢复损坏的数据,文本到图像生成,以及更多无穷无尽的应用程序生成对抗网络。
免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://yundeesoft.com/85466.html