生成对抗网络——一个简单的介绍及Python完整实现

生成对抗网络——一个简单的介绍及Python完整实现人们如今热衷于深入学习研究。结果,每天或每月都会发布新模型或新概念的新技术或体系结构。在判别模型中,算法试图将输入映射到输出,但他们不关心数据中的潜在变量。

大家好,欢迎来到IT知识分享网。

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

生成模型和判别模型

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

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

生成对抗网络——一个简单的介绍及Python完整实现

联合概率分布

然而,在生成模型中,算法尝试将输入映射到输出,并且还学习潜在变量和数据表示。因此,生成模型学习数据的联合概率分布。通过使用这个,我们可以从学习数据中生成新的数据点。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))最小化。简而言之,他们玩的是上面介绍的最小最大值游戏,并获得全局最优性。

生成对抗网络——一个简单的介绍及Python完整实现

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]。
生成对抗网络——一个简单的介绍及Python完整实现

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)),如前面讨论的原始方程饱和。

生成对抗网络——一个简单的介绍及Python完整实现

GAN生成的示例图像

结论

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

免责声明:本站所有文章内容,图片,视频等均是来源于用户投稿和互联网及文摘转载整编而成,不代表本站观点,不承担相关法律责任。其著作权各归其原作者或其出版社所有。如发现本站有涉嫌抄袭侵权/违法违规的内容,侵犯到您的权益,请在线联系站长,一经查实,本站将立刻删除。 本文来自网络,若有侵权,请联系删除,如若转载,请注明出处:https://yundeesoft.com/85466.html

(0)
上一篇 2024-09-27 13:33
下一篇 2024-09-29 05:27

相关推荐

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注

关注微信