深度学习中的自动编码器：TensorFlow示例

不念不忘少年蓝@ 2022-01-05 16:07 239阅读 0赞

#### 什么是自动编码器？ ####

自动编码器是重建输入的绝佳工具。简单来说，机器就是一个图像，可以生成一个密切相关的图片。这种神经网络中的输入是未标记的，这意味着网络能够在没有监督的情况下进行学习。更准确地说，输入由网络编码，仅关注最关键的特征。这是自动编码器因降维而流行的原因之一。此外，自动编码器可用于生成生成学习模型。例如，神经网络可以用一组面部训练，然后可以产生新的面部。

#### Autoencoder如何工作？ ####

自动编码器的目的是通过仅关注基本特征来产生输入的近似值。您可能会想到为什么不仅仅学习如何复制和粘贴输入以产生输出。实际上，自动编码器是一组约束，迫使网络学习表示数据的新方法，而不仅仅是复制输出。

典型的自动编码器定义有输入，内部表示和输出（输入的近似值）。学习发生在附加到内部表示的层中。实际上，有两个主要的层块看起来像传统的神经网络。稍有不同的是包含输出的图层必须等于输入。在下图中，原始输入进入称为**编码器**的第一个块。此内部表示压缩（缩小）输入的大小。在第二个块中发生输入的重建。这是解码阶段。

[![Image 1][]][Image 1 1]

该模型将通过最小化损失函数来更新权重。如果重建输出与输入不同，则模型受到惩罚。

具体地说，想象一个大小为50x50（即250像素）的图片和一个只有一个由100个神经元组成的隐藏层的神经网络。学习是在比输入小两倍的特征图上完成的。这意味着网络需要找到一种重建250像素的方法，只有一个神经元矢量等于100。

#### 堆叠自动编码器示例 ####

您将学习如何使用堆叠自动编码器。该架构类似于传统的神经网络。输入进入隐藏层以便压缩或减小其大小，然后到达重建层。目标是生成与原始图像一样接近的输出图像。模型必须学习在一组约束下实现其任务的方法，即具有较低维度的约束。

如今，自动编码器主要用于对图像进行去噪。想象一下有划痕的图像; 人类仍然能够识别内容。去噪自动编码器的想法是为图像添加噪声，迫使网络学习数据背后的模式。

另一个有用的自动编码器系列是变分自动编码器。这种类型的网络可以生成新图像。想象一下，你用一个男人的形象训练一个网络; 这样的网络可以产生新的面孔。

#### 使用TensorFlow构建自动编码器 ####

在本教程中，您将学习如何构建堆叠自动编码器以重建图像。

您将使用包含60000个32x32彩色图像的CIFAR-10数据集。数据集已经分为50000个图像用于训练，10000个用于测试。最多有十个班级：

*  飞机
 *  汽车
 *  鸟
 *  猫
 *  鹿
 *  狗
 *  青蛙
 *  马
 *  船
 *  卡车

您需要下载此URL中的图像https://www.cs.toronto.edu/~kriz/cifar.html并解压缩。-10-batches-py的文件夹包含五批数据，每个数据按随机顺序排列10000个。

--------------------

在构建和训练模型之前，需要应用一些数据处理。您将按以下步骤操作：

1.  导入数据
2.  将数据转换为黑白格式
3.  附加所有批次
4.  构建训练数据集
5.  构建图像可视化工具

#### 图像预处理 ####

###### 步骤1）导入数据 ######

根据官方网站，您可以使用以下代码上传数据。代码将使用数据和标签将数据加载到字典中。请注意，代码是一个函数。

import numpy as np
    import tensorflow as tf
    import pickle
    def unpickle(file):
        import pickle
        with open(file, 'rb') as fo:
            dict = pickle.load(fo, encoding='latin1')
        return dict

###### 步骤2）将数据转换为黑白格式 ######

为简单起见，您将数据转换为灰度。也就是说，对于颜色图像，仅有一个维度对三个维度。大多数神经网络仅适用于一维输入。

def grayscale(im):
        return im.reshape(im.shape[0], 3, 32, 32).mean(1).reshape(im.shape[0], -1)

步骤3）附加所有批次

既然已经创建了两个函数并且加载了数据集，那么您可以编写一个循环来将数据附加到内存中。如果仔细检查，带有数据的解压缩文件名为data\_batch\_，编号从1到5.您可以循环访问文件并将其附加到数据。

# Load the data into memory
    data, labels = [], []
    ## Loop over the b
    for i in range(1, 6):
        filename = './cifar-10-batches-py/data_batch_' + str(i)
        open_data = unpickle(filename)
        if len(data) > 0:
            data = np.vstack((data, open_data['data']))
            labels = np.hstack((labels, open_data['labels']))
        else:
            data = open_data['data']
            labels = open_data['labels']
    
    data = grayscale(data)
    x = np.matrix(data)
    y = np.array(labels)
    print(x.shape)
    (50000, 1024)

注意：将“./cifar-10-batches-py/data\_batch\_”更改为文件的实际位置。例如对于Windows机器，路径可以是filename =‘E：\\ cifar-10-batches-py \\ data\_batch\_’+ str（i）

###### 步骤4）构建训练数据集 ######

为了使训练更快更容易，您将仅在马图像上训练模型。马是标签数据中的第七类。如CIFAR-10数据集的文档中所述，每个类包含5000个图像。您可以打印数据的形状以确认有5000列的5000张图像。

horse_i = np.where(y == 7)[0]
    horse_x = x[horse_i]
    print(np.shape(horse_x)) 
    (5000, 1024)

###### 步骤5）构建图像可视化器 ######

最后，构建一个绘制图像的函数。您将需要此功能从自动编码器打印重建图像。

打印图像的简单方法是使用matplotlib库中的对象imshow。请注意，您需要将数据的形状从1024转换为32 \* 32（即图像的格式）。

# To plot pretty figures
    %matplotlib inline
    import matplotlib
    import matplotlib.pyplot as plt
    def plot_image(image, shape=[32, 32], cmap = "Greys_r"):
        plt.imshow(image.reshape(shape), cmap=cmap,interpolation="nearest")
        plt.axis("off")

该函数有3个参数：

*  图像：输入
 *  形状：列表，图像的尺寸
 *  Cmap：选择颜色图。默认情况下，灰色

您可以尝试在数据集中绘制第一个图像。你应该看到一个骑马的男人。

plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")

![1240][]

**设置数据集估算器**  
  好了，现在数据集已经可以使用了，你可以开始使用Tensorflow了。在构建模型之前，让我们使用Tensorflow的数据集估算器来提供网络。

您将使用TensorFlow估算器构建数据集。要刷新你的想法，你需要使用：

*  from\_tensor\_slices
 *  重复
 *  批量
 *  构建数据集的完整代码是：

dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)

请注意，x是占位符，具有以下形状：

*  \[None，n\_inputs\]：设置为None，因为网络的图像馈送数量等于批量大小。之后，您需要创建迭代器。没有这行代码，任何数据都不会通过管道。

iter = dataset.make_initializable_iterator（）#create iteratorfeatures = iter.get_next（）

现在管道已准备好，您可以检查第一张图像是否与之前相同（即马上的人）。  
![1240 1][]

您将批量大小设置为1，因为您只想用一个图像提供数据集。您可以使用print（sess.run（features）.shape）查看数据的维度。它等于（1,010）。1表示每个只有一个1024的图像。如果批量大小设置为2，则两个图像将通过管道。（不要改变批量大小。否则，它会抛出一个错误。一次只能有一个图像进入plot\_image（）函数。

## Parameters
    n_inputs = 32 * 32
    BATCH_SIZE = 1
    batch_size = tf.placeholder(tf.int64)
    
    # using a placeholder
    x = tf.placeholder(tf.float32, shape=[None,n_inputs])
    ## Dataset
    dataset = tf.data.Dataset.from_tensor_slices(x).repeat().batch(batch_size)
    iter = dataset.make_initializable_iterator() # create the iterator
    features = iter.get_next()
    
    ## Print the image
    with tf.Session() as sess:
        # feed the placeholder with data
        sess.run(iter.initializer, feed_dict={x: horse_x,
                                             batch_size: BATCH_SIZE}) 
        print(sess.run(features).shape) 
        plot_image(sess.run(features), shape=[32, 32], cmap = "Greys_r")
    (1, 1024)

--------------------

##### 建立网络 #####

现在是构建网络的时候了。您将训练堆叠自动编码器，即具有多个隐藏层的网络。您的网络将有一个1024点的输入图层，即32x32，即图像的形状。编码器块将具有一个具有300个神经元的顶部隐藏层，具有150个神经元的中心层。解码器块与编码器对称。您可以在下图中显示网络。请注意，您可以更改隐藏层和中间层的值。  
![1240 2][]

构建自动编码器与任何其他深度学习模型非常相似。

您将按照以下步骤构建模型：

*  定义参数
 *  定义图层
 *  定义架构
 *  定义优化
 *  运行模型
 *  评估模型

在上一节中，您学习了如何创建管道以提供模型，因此无需再次创建数据集。您将构建一个包含四个图层的自动编码器。您使用Xavier初始化。这是一种将初始权重设置为等于输入和输出的方差的技术。最后，使用洗脱激活功能。您使用L2正规化器来规范损耗函数。

###### 步骤1）定义参数 ######

第一步意味着定义每层中神经元的数量，学习速率和正则化器的超参数。在此之前，您将部分导入该功能。这是定义密集层参数的更好方法。下面的代码定义了自动编码器体系结构的值。如前所列，自动编码器有两层，第一层有300个神经元，第二层有150个神经元。它们的值存储在n\_hidden\_1和n\_hidden\_2中。

您需要定义学习速率和L2超参数。值存储在learning\_rate和l2\_reg中

from functools import partial
    
    ## Encoder
    n_hidden_1 = 300
    n_hidden_2 = 150  # codings
    
    ## Decoder
    n_hidden_3 = n_hidden_1
    n_outputs = n_inputs
    
    learning_rate = 0.01
    l2_reg = 0.0001

使用估算器contrib中的对象xavier\_initializer调用Xavier初始化技术。在同一个估算器中，您可以使用l2\_regularizer添加正则化器

## Define the Xavier initialization
    xav_init =  tf.contrib.layers.xavier_initializer()
    ## Define the L2 regularizer
    l2_regularizer = tf.contrib.layers.l2_regularizer(l2_reg)

###### 步骤2）定义图层 ######

已经设置了密集层的所有参数; 你可以使用object partial包装变量dense\_layer中的所有内容。dense\_layer，它使用ELU激活，Xavier初始化和L2正则化。

## Create the dense layer
    dense_layer = partial(tf.layers.dense,
                             activation=tf.nn.elu,
                             kernel_initializer=xav_init,
                             kernel_regularizer=l2_regularizer)

###### 步骤3）定义架构 ######

如果你看一下架构的图片，你会注意到网络堆叠了三层带有输出层。在下面的代码中，您连接适当的图层。例如，第一层计算输入矩阵特征与包含300个权重的矩阵之间的点积。计算点积后，输出转到Elu激活功能。输出成为下一层的输入，这就是您使用它来计算hidden\_2等的原因。每个图层的矩阵乘法相同，因为您使用相同的激活函数。请注意，最后一层输出不应用激活功能。这是有道理的，因为这是重建的输入

## Make the mat mul
    hidden_1 = dense_layer(features, n_hidden_1)
    hidden_2 = dense_layer(hidden_1, n_hidden_2)
    hidden_3 = dense_layer(hidden_2, n_hidden_3)
    outputs = dense_layer(hidden_3, n_outputs, activation=None)

###### 步骤4）定义优化 ######

最后一步是构造优化器。您使用均方误差作为损失函数。如果您回想一下关于线性回归的教程，您就会知道MSE是根据预测输出和实际标签之间的差异来计算的。这里，标签是特征，因为模型试图重建输入。因此，您需要预测输出和输入之间的平方差之和的平均值。使用TensorFlow，您可以编写损失函数，如下所示：

loss = tf.reduce_mean（tf.square（outputs  -  features））

然后，您需要优化损失函数。您使用Adam优化器来计算渐变。目标函数是尽量减少损失。

## Optimize
    loss = tf.reduce_mean(tf.square(outputs - features))
    optimizer = tf.train.AdamOptimizer(learning_rate)
    train  = optimizer.minimize(loss)

在训练模型之前还有一个设置。您希望使用批量大小为150，即每次迭代为管道提供150个图像。您需要手动计算迭代次数。这是微不足道的：

如果您想每次传递150张图像，并且您知道数据集中有5000张图像，则迭代次数等于。在python中，您可以运行以下代码并确保输出为33：

BATCH_SIZE = 150
    ### Number of batches :  length dataset / batch size
    n_batches = horse_x.shape[0] // BATCH_SIZE
    print(n_batches)
    33

###### 步骤5）运行模型 ######

最后但同样重要的是，训练模型。你正在用100个时代训练模型。也就是说，模型将看到100倍的图像到优化的权重。

您已熟悉在Tensorflow中训练模型的代码。稍有不同的是在运行培训之前管道数据。通过这种方式，模型训练更快。

您有兴趣在十个时期之后打印损失，以查看模型是否正在学习某些东西（即损失正在减少）。培训需要2到5分钟，具体取决于您的机器硬件。

## Set params
    n_epochs = 100
    
    ## Call Saver to save the model and re-use it later during evaluation
    saver = tf.train.Saver()
    
    with tf.Session() as sess:
        sess.run(tf.global_variables_initializer())
        # initialise iterator with train data
        sess.run(iter.initializer, feed_dict={x: horse_x,
                                              batch_size: BATCH_SIZE})
        print('Training...')
        print(sess.run(features).shape) 
        for epoch in range(n_epochs):       
            for iteration in range(n_batches):
                sess.run(train)
            if epoch % 10 == 0:
                loss_train = loss.eval()   # not shown
                print("\r{}".format(epoch), "Train MSE:", loss_train) 
            #saver.save(sess, "./my_model_all_layers.ckpt") 
        save_path = saver.save(sess, "./model.ckpt")    
        print("Model saved in path: %s" % save_path)  
    Training...
    (150, 1024)
    0 Train MSE: 2934.455
    10 Train MSE: 1672.676
    20 Train MSE: 1514.709
    30 Train MSE: 1404.3118
    40 Train MSE: 1425.058
    50 Train MSE: 1479.0631
    60 Train MSE: 1609.5259
    70 Train MSE: 1482.3223
    80 Train MSE: 1445.7035
    90 Train MSE: 1453.8597
    Model saved in path: ./model.ckpt

###### 步骤6）评估模型 ######

现在你已经训练了模型，现在是时候进行评估了。您需要从文件/ cifar-10-batches-py /导入测试sert。

test_data = unpickle('./cifar-10-batches-py/test_batch')
    test_x = grayscale(test_data['data'])
    #test_labels = np.array(test_data['labels'])

注意：对于Windows机器，代码变为test\_data = unpickle（r“E：\\ cifar-10-batches-py \\ test\_batch”）

您可以尝试打印图像13，这是一匹马

plot_image(test_x[13], shape=[32, 32], cmap = "Greys_r")

![1240 3][]

要评估模型，您将使用此图像的像素值，并查看编码器是否可以在缩小1024像素后重建相同的图像。请注意，您定义了一个函数来评估不同图片上的模型。该模型应该只适用于马匹。

**该函数有两个参数：**

*  df：导入测试数据
 *  image\_number：指示要导入的图像

**该功能分为三个部分：**

1.  将图像重塑为正确的尺寸，即1,1024
2.  使用看不见的图像输入模型，对图像进行编码/解码
3.  打印真实和重建的图像

def reconstruct_image(df, image_number = 1):
        ## Part 1: Reshape the image to the correct dimension i.e 1, 1024
        x_test = df[image_number]
        x_test_1 = x_test.reshape((1, 32*32))
        
        ## Part 2: Feed the model with the unseen image, encode/decode the image
        with tf.Session() as sess:     
            sess.run(tf.global_variables_initializer()) 
            sess.run(iter.initializer, feed_dict={x: x_test_1,
                                          batch_size: 1})
        ## Part 3:  Print the real and reconstructed image
          # Restore variables from disk.
            saver.restore(sess, "./model.ckpt")  
            print("Model restored.")
          # Reconstruct image
            outputs_val = outputs.eval()
            print(outputs_val.shape)
            fig = plt.figure()
          # Plot real
            ax1 = fig.add_subplot(121)
            plot_image(x_test_1, shape=[32, 32], cmap = "Greys_r")
          # Plot estimated
            ax2 = fig.add_subplot(122)
            plot_image(outputs_val, shape=[32, 32], cmap = "Greys_r")
            plt.tight_layout()
            fig = plt.gcf()

现在已经定义了评估函数，您可以查看重建的图像编号十三

reconstruct_image(df =test_x, image_number = 13)

INFO:tensorflow:Restoring parameters from ./model.ckpt
    Model restored.
    (1, 1024)

![1240 4][]

**摘要**

自动编码器的主要目的是压缩输入数据，然后将其解压缩为与原始数据非常相似的输出。  
  自动编码器的体系结构与称为中心层的枢轴层对称。

您可以使用以下命令创建自动编码器：  
部分：使用典型设置创建密集层：

tf.layers.dense,                         
      	activation=tf.nn.elu,                         
      	kernel_initializer=xav_init,                         
      	kernel_regularizer=l2_regularizer

dense\_layer（）：使矩阵乘法  
您可以使用以下命令定义损失函数和优化：

loss = tf.reduce_mean(tf.square(outputs - features))
    optimizer = tf.train.AdamOptimizer(learning_rate)
    train  = optimizer.minimize(loss)

最后运行一个会话来训练模型。  
**说到这里，你掌握了吗？**

转载于:https://www.cnblogs.com/SXTAIStudy/p/10416618.html

[Image 1]: 
[Image 1 1]: https://www.guru99.com/images/tensorflow/082918_0649_Autoencoder1.png
[1240]: /images/20211228/99173a923eaa436fae409f9c8c7b155d.png
[1240 1]: /images/20211228/f8ada1a858d3456ca14ef1b4f7367979.png
[1240 2]: /images/20211228/84a7d7a02135436da22f4cf4c73f2ef2.png
[1240 3]: /images/20211228/5d9b5b070e5745feb8e294d851e28cf0.png
[1240 4]: /images/20211228/f89808dbdd684164b11d0ce1a3e93833.png