如何使用TensorFlow和自编码器模型生成手写数字

自编码器是一种能够用来学习对输入数据高效编码的神经网络。若给定一些输入，神经网络首先会使用一系列的变换来将数据映射到低维空间，这部分神经网络就被称为编码器。

然后，网络会使用被编码的低维数据去尝试重建输入，这部分网络称之为解码器。我们可以使用编码器将数据压缩为神经网络可以理解的类型。然而自编码器很少用做这个目的，因为通常存在比它更为有效的手工编写的算法(例如 jpg 压缩)。

此外，自编码器还被经常用来执行降噪任务，它能够学会如何重建原始图像。

什么是变分自编码器?

有很多与自编码器相关的有趣应用。

其中之一被称为变分自编码器(variational autoencoder)。使用变分自编码器不仅可以压缩数据–还能生成自编码器曾经遇到过的新对象。

使用通用自编码器的时候，我们根本不知道网络所生成的编码具体是什么。虽然我们可以对比不同的编码对象，但是要理解它内部编码的方式几乎是不可能的。这也就意味着我们不能使用编码器来生成新的对象。我们甚至连输入应该是什么样子的都不知道。

而我们用相反的方法使用变分自编码器。我们不会尝试着去关注隐含向量所服从的分布，只需要告诉网络我们想让这个分布转换为什么样子就行了。

通常情况，我们会限制网络来生成具有单位正态分布性质的隐含向量。然后，在尝试生成数据的时候，我们只需要从这种分布中进行采样，然后把样本喂给解码器就行，解码器会返回新的对象，看上去就和我们用来训练网络的对象一样。

下面我们将介绍如何使用 Python 和 TensorFlow 实现这一过程，我们要教会我们的网络来画 MNIST 字符。

第一步加载训练数据

首先我们来执行一些基本的导入操作。TensorFlow 具有非常便利的函数来让我们能够很容易地访问 MNIST 数据集。

 
 
 
    
  
  
  
  1. import tensorflow as tfimport numpy as npimport matplotlib.pyplot as plt 
    2.   
  
  
  2.  
    3.   
  
  
  3. %matplotlib inlinefrom tensorflow.examples.tutorials.mnist import input_data 
    4.   
  
  
  4.  
    5.   
  
  
  5. mnist = input_data.read_data_sets('MNIST_data')  
    6.

定义输入数据和输出数据

MNIST 图像的维度是 28*28 像素，只有单色通道。我们的输入数据 X_in 是一批一批的 MNIST 字符，网络会学习如何重建它们。然后在一个占位符 Y 中输出它们，输出和输入具有相同的维度。

Y_flat 将会在后面计算损失函数的时候用到，keep_prob 将会在应用 dropout 的时候用到(作为一种正则化的方法)。在训练的过程中，它的值会设为 0.8，当生成新数据的时候，我们不使用 dropout，所以它的值会变成 1。

lrelu 函数需要自及定义，因为 TensorFlow 中并没有预定义一个 Leaky ReLU 函数。

 
 
 
    
  
  
  
  1. tf.reset_default_graph() 
    2.   
  
  
  2.  
    3.   
  
  
  3. batch_size = 64X_in = tf.placeholder(dtype=tf.float32, shape=[None, 28, 28], name='X') 
    4.   
  
  
  4. Y    = tf.placeholder(dtype=tf.float32, shape=[None, 28, 28], name='Y') 
    5.   
  
  
  5. Y_flat = tf.reshape(Y, shape=[-1, 28 * 28]) 
    6.   
  
  
  6. keep_prob = tf.placeholder(dtype=tf.float32, shape=(), name='keep_prob') 
    7.   
  
  
  7.  
    8.   
  
  
  8. dec_in_channels = 1n_latent = 8reshaped_dim = [-1, 7, 7, dec_in_channels] 
    9.   
  
  
  9. inputs_decoder = 49 * dec_in_channels / 2def lrelu(x, alpha=0.3):    return tf.maximum(x, tf.multiply(x, alpha))  
    10.

定义编码器

因为我们的输入是图像，所以使用一些卷积变换会更加合理。最值得注意的是我们在编码器中创建了两个向量，因为编码器应该创建服从高斯分布的对象。

  • 一个是均值向量
  • 一个是标准差向量

在后面你会看到，我们是如何「强制」编码器来保证它确实生成 了服从正态分布的数据点，我们可以把将会被输入到解码器中的编码值表示为 z。在计算损失函数的时候，我们会需要我们所选分布的均值和标准差。

 
 
 
    
  
  
  
  1. def encoder(X_in, keep_prob): 
    2.   
  
  
  2.     activation = lrelu    with tf.variable_scope("encoder", reuse=None): 
    3.   
  
  
  3.         X = tf.reshape(X_in, shape=[-1, 28, 28, 1]) 
    4.   
  
  
  4.         x = tf.layers.conv2d(X, filters=64, kernel_size=4, strides=2, padding='same', activation=activation) 
    5.   
  
  
  5.         x = tf.nn.dropout(x, keep_prob) 
    6.   
  
  
  6.         x = tf.layers.conv2d(x, filters=64, kernel_size=4, strides=2, padding='same', activation=activation) 
    7.   
  
  
  7.         x = tf.nn.dropout(x, keep_prob) 
    8.   
  
  
  8.         x = tf.layers.conv2d(x, filters=64, kernel_size=4, strides=1, padding='same', activation=activation) 
    9.   
  
  
  9.         x = tf.nn.dropout(x, keep_prob) 
    10.   
  
  
  10.         x = tf.contrib.layers.flatten(x) 
    11.   
  
  
  11.         mn = tf.layers.dense(x, units=n_latent) 
    12.   
  
  
  12.         sd       = 0.5 * tf.layers.dense(x, units=n_latent)             
    13.   
  
  
  13.         epsilon = tf.random_normal(tf.stack([tf.shape(x)[0], n_latent]))  
    14.   
  
  
  14.         z  = mn + tf.multiply(epsilon, tf.exp(sd))         
    15.   
  
  
  15.         return z, mn, sd  
    16.

定义解码器

解码器不会关心输入值是不是从我们定义的某个特定分布中采样得到的。它仅仅会尝试重建输入图像。最后，我们使用了一系列的转置卷积(transpose convolution)。

 
 
 
    
  
  
  
  1. def decoder(sampled_z, keep_prob):    with tf.variable_scope("decoder", reuse=None): 
    2.   
  
  
  2.         x = tf.layers.dense(sampled_z, units=inputs_decoder, activation=lrelu) 
    3.   
  
  
  3.         x = tf.layers.dense(x, units=inputs_decoder * 2 + 1, activation=lrelu) 
    4.   
  
  
  4.         x = tf.reshape(x, reshaped_dim) 
    5.   
  
  
  5.         x = tf.layers.conv2d_transpose(x, filters=64, kernel_size=4, strides=2, padding='same', activation=tf.nn.relu) 
    6.   
  
  
  6.         x = tf.nn.dropout(x, keep_prob) 
    7.   
  
  
  7.         x = tf.layers.conv2d_transpose(x, filters=64, kernel_size=4, strides=1, padding='same', activation=tf.nn.relu) 
    8.   
  
  
  8.         x = tf.nn.dropout(x, keep_prob) 
    9.   
  
  
  9.         x = tf.layers.conv2d_transpose(x, filters=64, kernel_size=4, strides=1, padding='same', activation=tf.nn.relu) 
    10.   
  
  
  10.          
    11.   
  
  
  11.         x = tf.contrib.layers.flatten(x) 
    12.   
  
  
  12.         x = tf.layers.dense(x, units=28*28, activation=tf.nn.sigmoid) 
    13.   
  
  
  13.         img = tf.reshape(x, shape=[-1, 28, 28])        return img  
    14.

现在，我们将两部分连在一起。

 
 
 
    
  
  
  
  1. sampled, mn, sd = encoder(X_in, keep_prob) 
    2.   
  
  
  2.  
    3.   
  
  
  3. dec = decoder(sampled, keep_prob)  
    4.

计算损失函数，并实施一个高斯隐藏分布

为了计算图像重构的损失函数，我们简单地使用了平方差(这有时候会使图像变得有些模糊)。这个损失函数还结合了 KL 散度，这确保了我们的隐藏值将会从一个标准分布中采样。关于这个主题，如果想要了解更多，可以看一下这篇文章(https://jaan.io/what-is-variational-autoencoder-vae-tutorial/)。

 
 
 
    
  
  
  
  1. unreshaped = tf.reshape(dec, [-1, 28*28]) 
    2.   
  
  
  2. img_loss = tf.reduce_sum(tf.squared_difference(unreshaped, Y_flat), 1) 
    3.   
  
  
  3. latent_loss = -0.5 * tf.reduce_sum(1.0 + 2.0 * sd - tf.square(mn) - tf.exp(2.0 * sd), 1) 
    4.   
  
  
  4. loss = tf.reduce_mean(img_loss + latent_loss) 
    5.   
  
  
  5. optimizer = tf.train.AdamOptimizer(0.0005).minimize(loss) 
    6.   
  
  
  6. sess = tf.Session() 
    7.   
  
  
  7. sess.run(tf.global_variables_initializer())  
    8.

训练网络

现在我们终于可以训练我们的 VAE 了!

每隔 200 步，我们会看一下当前的重建是什么样子的。大约在处理了 2000 次迭代后，大多数重建看上去是挺合理的。

 
 
 
    
  
  
  
  1. for i in range(30000): 
    2.   
  
  
  2.     batch = [np.reshape(b, [28, 28]) for b in mnist.train.next_batch(batch_size=batch_size)[0]] 
    3.   
  
  
  3.     sess.run(optimizer, feed_dict = {X_in: batch, Y: batch, keep_prob: 0.8})         
    4.   
  
  
  4.     if not i % 200: 
    5.   
  
  
  5.         ls, d, i_ls, d_ls, mu, sigm = sess.run([loss, dec, img_loss, dst_loss, mn, sd], feed_dict = {X_in: batch, Y: batch, keep_prob: 1.0}) 
    6.   
  
  
  6.         plt.imshow(np.reshape(batch[0], [28, 28]), cmap='gray') 
    7.   
  
  
  7.         plt.show() 
    8.   
  
  
  8.         plt.imshow(d[0], cmap='gray') 
    9.   
  
  
  9.         plt.show() 
    10.   
  
  
  10.         print(i, ls, np.mean(i_ls), np.mean(d_ls))  
    11.

生成新数据

最惊人的是我们现在可以生成新的字符了。最后，我们仅仅是从一个单位正态分布里面采集了一个值，输入到解码器。生成的大多数字符都和人类手写的是一样的。

 
 
 
    
  
  
  
  1. randoms = [np.random.normal(0, 1, n_latent) for _ in range(10)] 
    2.   
  
  
  2. imgs = sess.run(dec, feed_dict = {sampled: randoms, keep_prob: 1.0}) 
    3.   
  
  
  3. imgs = [np.reshape(imgs[i], [28, 28]) for i in range(len(imgs))]for img in imgs: 
    4.   
  
  
  4.     plt.figure(figsize=(1,1)) 
    5.   
  
  
  5.     plt.axis('off') 
    6.   
  
  
  6.     plt.imshow(img, cmap='gray')  
    7.

一些自动生成的字符。

总结

这是关于 VAE 应用一个相当简单的例子。但是可以想象一下更多的可能性!神经网络可以学习谱写音乐，它们可以自动地创建对书籍、游戏的描述。借用创新思维，VAE 可以为一些新颖的项目开创空间。

标题名称：如何使用TensorFlow和自编码器模型生成手写数字
标题链接：http://www.shufengxianlan.com/qtweb/news35/479735.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

电子商务知识

各行业网站

成都网站建设　　 　发电机组维修保养　　 　网站设计　　 　橡塑板　　 　绵阳电信机房　　 　网站推广　　 　成都艺考培训　　 　成都企业网站定制　　 　网站SEO优化　　 　成都全网营销　　 　手机网站开发　　 　网站营销推广　　 　成都光华电信机房　　 　成都网站设计　　 　成都微信二次开发公司　　 　成都法律咨询　　 　申请域名　　 　普能电气　　 　app软件开发　　 　成都网站维护