TensorFlow 中的自动编码器(附示例)
深度学习中的自动编码器是什么?
An 自动编码器 是一种以无监督方式高效学习数据编码的工具。它是一种人工神经网络,通过训练神经网络忽略信号噪声,帮助您学习数据集的表示以进行降维。它是重建输入的绝佳工具。
简单来说,机器可以拍摄一张图像,并生成一张密切相关的图片。这种神经网络的输入是未标记的,这意味着网络能够在没有监督的情况下学习。更准确地说,网络对输入进行编码,以仅关注最关键的特征。这是自动编码器因降维而流行的原因之一。此外,自动编码器可用于生成 生成学习模型例如,可以用一组面孔来训练神经网络,然后可以产生新的面孔。
TensorFlow Autoencoder 如何工作?
自动编码器的目的是通过仅关注基本特征来产生输入的近似值。您可能会想,为什么不只是学习如何复制和粘贴输入来产生输出呢?事实上,自动编码器是一组约束,它迫使网络学习新的方式来表示数据,而不仅仅是复制输出。
典型的自动编码器由输入、内部表示和输出(输入的近似值)定义。学习发生在附加到内部表示的层中。事实上,有两个主要的层块,看起来像传统的神经网络。略有不同的是包含输出的层必须等于输入。在下图中,原始输入进入第一个称为 编码器。这种内部表示会压缩(减小)输入的大小。在第二个块中,将重建输入。这是解码阶段。
模型将通过最小化损失函数来更新权重。如果重建输出与输入不同,则模型会受到惩罚。
具体来说,想象一张 50×50(即 250 像素)大小的图片和一个只有一个隐藏层(由一百个神经元组成)的神经网络。学习是在比输入小两倍的特征图上进行的。这意味着网络需要找到一种方法来仅用一个等于 250 的神经元向量来重建 100 像素。
堆叠自动编码器示例
在本 Autoencoder 教程中,您将学习如何使用堆叠式自动编码器。该架构类似于传统的神经网络。输入进入隐藏层以进行压缩或减小其大小,然后到达重建层。目标是生成与原始图像尽可能接近的输出图像。模型必须学习在一组约束下(即在较低维度下)完成其任务的方法。
如今,自动编码器 深度学习 主要用于对图像进行去噪。想象一下有划痕的图像;人类仍然能够识别内容。去噪自动编码器的理念是向图片添加噪声,以迫使网络学习数据背后的模式。
自动编码器深度学习的另一个有用的家族是变分自动编码器。这种类型的网络可以生成新的图像。想象一下,你用一个人的图像训练一个网络;这样的网络可以产生新的面孔。
如何使用 TensorFlow 构建自动编码器
在本教程中,您将学习如何构建堆叠自动编码器来重建图像。
您将使用 CIFAR-10数据集 其中包含 60000 张 32×32 彩色图像。Autoencoder 数据集已分为 50000 张用于训练的图像和 10000 张用于测试的图像。最多有十个类别:
- 飞机
- 汽车
- 鸟
- 猫
- 鹿
- 狗
- 青蛙
- 马
- 船
- 卡车
您需要从此 URL https://www.cs.toronto.edu/~kriz/cifar.html 下载图像并解压。文件夹 for-10-batches-py 包含五批数据,每批包含 10000 张图像,顺序随机。
在构建和训练模型之前,您需要进行一些数据处理。您将按以下步骤操作:
- 导入数据
- 将数据转换为黑白格式
- 附加所有批次
- 构建训练数据集
- 构建图像可视化工具
图像预处理
步骤1)导入数据
根据官方网站,您可以使用以下代码上传数据。Autoencoder 代码将使用以下代码将数据加载到字典中: data 和 标签。注意代码是一个函数。
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。您可以循环遍历文件并将其附加到数据中。
完成此步骤后,将颜色数据转换为灰度格式。如您所见,数据的形状为 50000 和 1024。32*32 像素现在平坦化为 2014。
# 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 张图像。您可以打印数据的形状以确认有 5.000 张图像和 1024 列,如下所示 TensorFlow 自动编码器示例步骤。
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 个参数:
- 图片:输入
- 形状:列表,图像的尺寸
- 地图:选择颜色图。默认情况下,灰色
您可以尝试绘制数据集中的第一幅图像。您应该看到一个骑在马上的男人。
plot_image(horse_x[1], shape=[32, 32], cmap = "Greys_r")
设置数据集估计器
好了,现在数据集已经可以使用了,您可以开始使用 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 the iteratorfeatures = iter.get_next()
现在管道已经准备就绪,您可以检查第一张图像是否与之前相同(即,马背上的一个人)。
您将批处理大小设置为 1,因为您只想向数据集提供一张图像。您可以使用 print(sess.run(features).shape) 查看数据的维度。它等于 (1, 1024)。1 表示每次只提供一张 1024 的图像。如果将批处理大小设置为 XNUMX,则两张图像将通过管道。(不要更改批处理大小。否则会引发错误。每次只能将一张图像传递给函数 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 个点,即 32×32,即图像的形状。
编码器块将有一个顶部隐藏层,其中包含 300 个神经元,一个中心层,其中包含 150 个神经元。解码器块与编码器对称。您可以在下图中直观地看到网络。请注意,您可以更改隐藏层和中心层的值。
构建自动编码器与任何其他深度学习模型非常相似。
您将按照以下步骤构建模型:
- 定义参数
- 定义图层
- 定义架构
- 定义优化
- 运行模型
- 评估模型
在上一节中,您学习了如何创建管道来为模型提供数据,因此无需再次创建数据集。您将构建一个具有四层的自动编码器。您使用 Xavier 初始化。这是一种将初始权重设置为等于输入和输出的方差的技术。最后,您使用 elu 激活函数。您使用 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
Xavier 初始化技术通过来自估计器贡献的对象 xavier_initializer 调用。在同一个估计器中,您可以使用 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) 定义图层
所有密集层的参数都已设置好;您可以使用对象 partial.dense_layer 将所有内容打包到变量 density_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 中训练模型的代码。略有不同的是,在运行训练之前先管道数据。这样,模型训练速度更快。
您希望打印十个 epoch 后的损失,以查看模型是否正在学习某些东西(即损失是否在减少)。训练需要 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")
为了评估模型,您将使用此图像的像素值,并查看编码器是否可以在缩小 1024 个像素后重建相同的图像。请注意,您定义了一个函数来评估不同图片上的模型。该模型应该只在马匹上效果更好。
该函数接受两个参数:
- df:导入测试数据
- 图像编号:指示要导入什么图像
该函数分为三部分:
- 将图像重塑为正确的尺寸,即 1
- 将未见过的图像输入到模型中,对图像进行编码/解码
- 打印真实图像和重建图像
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)
结语
- 自动编码器的主要目的是压缩输入数据,然后将其解压缩为与原始数据非常相似的输出。
- 自动编码器的架构与称为中心层的枢轴层对称。
- 您可以使用以下方式创建自动编码器:
局部的:使用典型设置创建密集层:
tf.layers.dense, activation=tf.nn.elu, kernel_initializer=xav_init, kernel_regularizer=l2_regularizer
密集层():进行矩阵乘法
loss = tf.reduce_mean(tf.square(outputs - features)) optimizer = tf.train.AdamOptimizer(learning_rate) train = optimizer.minimize(loss)