自编码器

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/marsjhao/article/details/73480859

一、什么是自编码器(Autoencoder)

自动编码器是一种数据的压缩算法,其中数据的压缩和解压缩函数是数据相关的、有损的、从样本中自动学习的。在大部分提到自动编码器的场合,压缩和解压缩的函数是通过神经网络实现的。

1)自动编码器是数据相关的(data-specific 或 data-dependent),这意味着自动编码器只能压缩那些与训练数据类似的数据。比如,使用人脸训练出来的自动编码器在压缩别的图片,比如树木时性能很差,因为它学习到的特征是与人脸相关的。

2)自动编码器是有损的,意思是解压缩的输出与原来的输入相比是退化的,MP3,JPEG等压缩算法也是如此。这与无损压缩算法不同。

3)自动编码器是从数据样本中自动学习的,这意味着很容易对指定类的输入训练出一种特定的编码器,而不需要完成任何新工作。

搭建一个自动编码器需要完成下面三样工作:搭建编码器,搭建解码器,设定一个损失函数,用以衡量由于压缩而损失掉的信息。编码器和解码器一般都是参数化的方程,并关于损失函数可导,典型情况是使用神经网络。编码器和解码器的参数可以通过最小化损失函数而优化,例如SGD。

自编码器是一个自监督的算法,并不是一个无监督算法。自监督学习是监督学习的一个实例,其标签产生自输入数据。要获得一个自监督的模型,你需要一个靠谱的目标跟一个损失函数,仅仅把目标设定为重构输入可能不是正确的选项。基本上,要求模型在像素级上精确重构输入不是机器学习的兴趣所在,学习到高级的抽象特征才是。事实上,当主要任务是分类、定位之类的任务时,那些对这类任务而言的最好的特征基本上都是重构输入时的最差的那种特征。

目前自编码器的应用主要有两个方面,第一是数据去噪,第二是为进行可视化而降维。配合适当的维度和稀疏约束,自编码器可以学习到比PCA等技术更有意思的数据投影。

对于2D的数据可视化,t-SNE(读作tee-snee)或许是目前最好的算法,但通常还是需要原数据的维度相对低一些。所以,可视化高维数据的一个好办法是首先使用自编码器将维度降低到较低的水平(如32维),然后再使用t-SNE将其投影在2D平面上。

二、几种自编码器

自编码器(autoencoder)是神经网络的一种,经过训练后能尝试将输入复制到输出。自编码器()autoencoder)内部有一个隐藏层 h,可以产生编码(code)表示输入。该网络可以看作由两部分组成:一个由函数 h = f(x) 表示的编码器和一个生成重构的解码器 r = g(h)。如果一个自编码器只是简单地学会将处处设置为 g(f(x)) = x,那么这个自编码器就没什么特别的用处。相反,我们不应该将自编码器设计成输入到输出完全相等。这通常需要向自编码器强加一些约束,使它只能近似地复制,并只能复制与训练数据相似的输入。这些约束强制模型考虑输入数据的哪些部分需要被优先复制,因此它往往能学习到数据的有用特性。

1. 欠完备自编码器

从自编码器获得有用特征的一种方法是限制 h的维度比 x 小,这种编码维度小于输入维度的自编码器称为欠完备(undercomplete)自编码器。学习欠完备的表示将强制自编码器捕捉训练数据中最显著的特征。

学习过程可以简单地描述为最小化一个损失函数L(x,g(f(x))),其中 L 是一个损失函数,惩罚g(f(x)) 与 x 的差异,如均方误差。当解码器是线性的且 L 是均方误差,欠完备的自编码器会学习出与 PCA 相同的生成子空间。这种情况下,自编码器在训练来执行复制任务的同时学到了训据的主元子空间。如果编码器和解码器被赋予过大的容量,自编码器会执行复制任务而捕捉不到任何有关数据分布的有用信息。

2. 正则自编码器

正则自编码器使用的损失函数可以鼓励模型学习其他特性(除了将输入复制到输出),而不必限制使用浅层的编码器和解码器以及小的编码维数来限制模型的容量。这些特性包括稀疏表示、表示的小导数、以及对噪声或输入缺失的鲁棒性。即使模型容量大到足以学习一个无意义的恒等函数,非线性且过完备的正则自编码器仍然能够从数据中学到一些关于数据分布的有用信息。

2.1 稀疏自编码器

稀疏自编码器简单地在训练时结合编码层的稀疏惩罚 Ω(h) 和重构误差:L(x,g(f(x))) + Ω(h),其中 g(h) 是解码器的输出,通常 h 是编码器的输出,即 h = f(x)。稀疏自编码器一般用来学习特征,以便用于像分类这样的任务。稀疏正则化的自编码器必须反映训练数据集的独特统计特征,而不是简单地充当恒等函数。以这种方式训练,执行附带稀疏惩罚的复制任务可以得到能学习有用特征的模型。

2.2 去噪自编码器

去噪自编码器(denoisingautoencoder, DAE)最小化L(x,g(f(˜ x))),其中 ˜ x 是被某种噪声损坏的 x 的副本。因此去噪自编码器必须撤消这些损坏,而不是简单地复制输入。

2.3 收缩自编码器

另一正则化自编码器的策略是使用一个类似稀疏自编码器中的惩罚项 Ω,

这迫使模型学习一个在 x 变化小时目标也没有太大变化的函数。因为这个惩罚只对训练数据适用,它迫使自编码器学习可以反映训练数据分布信息的特征。这样正则化的自编码器被称为收缩自编码器(contractive autoencoder, CAE)。这种方法与去噪自编码器、流形学习和概率模型存在一定理论联系。

3. 表示能力、层的大小和深度

万能近似定理保证至少有一层隐藏层且隐藏单元足够多的前馈神经网络能以任意精度近似任意函数(在很大范围里),这是非平凡深度(至少有一层隐藏层)的一个主要优点。这意味着具有单隐藏层的自编码器在数据域内能表示任意近似数据的恒等函数。但是,从输入到编码的映射是浅层的。这意味这我们不能任意添加约束,比如约束编码稀疏。深度自编码器(编码器至少包含一层额外隐藏层)在给定足够多的隐藏单元的情况下,能以任意精度近似任何从输入到编码的映射。

深度可以指数地降低表示某些函数的计算成本。深度也能指数地减少学习一些函数所需的训练数据量。实验中,深度自编码器能比相应的浅层或线性自编码器产生更好的压缩效率。

训练深度自编码器的普遍策略是训练一堆浅层的自编码器来贪心地预训练相应的深度架构。所以即使最终目标是训练深度自编码器,我们也经常会遇到浅层自编码器。

4. 去噪自编码器

去噪自编码器(denoisingautoencoder, DAE)是一类接受损坏数据作为输入,并训练来预测原始未被损坏数据作为输出的自编码器。

DAE 的训练准则(条件高斯p(x | h))能让自编码器学到能估计数据分布得分的向量场 (g(f(x)) − x) ,这是 DAE 的一个重要特性。

5. 收缩自编码器

收缩自编码器 (Rifai et al.,2011a,b) 在编码 h = f(x) 的基础上添加了显式的正则项,鼓励 f 的导数尽可能小:

惩罚项 Ω(h) 为平方 Frobenius范数(元素平方之和),作用于与编码器的函数相关偏导数的 Jacobian 矩阵。

收缩(contractive)源于 CAE 弯曲空间的方式。具体来说,由于 CAE 训练为抵抗输入扰动,鼓励将输入点邻域映射到输出点处更小的邻域。我们能认为这是将输入的邻域收缩到更小的输出邻域。

三、使用Keras建立简单的自编码器

1. 单隐含层自编码器

建立一个全连接的编码器和解码器。也可以单独使用编码器和解码器,在此使用Keras的函数式模型API即Model可以灵活地构建自编码器。

50个epoch后,看起来我们的自编码器优化的不错了,损失val_loss: 0.1037。

  1. from keras.layers import Input, Dense
  2. from keras.models import Model
  3. from keras.datasets import mnist
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. (x_train, _), (x_test, _) = mnist.load_data()
  7. x_train = x_train.astype('float32') / 255.
  8. x_test = x_test.astype('float32') / 255.
  9. x_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))
  10. x_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))
  11. print(x_train.shape)
  12. print(x_test.shape)
  13. encoding_dim = 32
  14. input_img = Input(shape=(784,))
  15. encoded = Dense(encoding_dim, activation='relu')(input_img)
  16. decoded = Dense(784, activation='sigmoid')(encoded)
  17. autoencoder = Model(inputs=input_img, outputs=decoded)
  18. encoder = Model(inputs=input_img, outputs=encoded)
  19. encoded_input = Input(shape=(encoding_dim,))
  20. decoder_layer = autoencoder.layers[-1]
  21. decoder = Model(inputs=encoded_input, outputs=decoder_layer(encoded_input))
  22. autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
  23. autoencoder.fit(x_train, x_train, epochs=50, batch_size=256,
  24. shuffle=True, validation_data=(x_test, x_test))
  25. encoded_imgs = encoder.predict(x_test)
  26. decoded_imgs = decoder.predict(encoded_imgs)
  27. n = 10 # how many digits we will display
  28. plt.figure(figsize=(20, 4))
  29. for i in range(n):
  30. ax = plt.subplot(2, n, i + 1)
  31. plt.imshow(x_test[i].reshape(28, 28))
  32. plt.gray()
  33. ax.get_xaxis().set_visible(False)
  34. ax.get_yaxis().set_visible(False)
  35. ax = plt.subplot(2, n, i + 1 + n)
  36. plt.imshow(decoded_imgs[i].reshape(28, 28))
  37. plt.gray()
  38. ax.get_xaxis().set_visible(False)
  39. ax.get_yaxis().set_visible(False)
  40. plt.show()

2. 稀疏自编码器、深层自编码器

为码字加上稀疏性约束。如果我们对隐层单元施加稀疏性约束的话,会得到更为紧凑的表达,只有一小部分神经元会被激活。在Keras中,我们可以通过添加一个activity_regularizer达到对某层激活值进行约束的目的。

encoded = Dense(encoding_dim, activation='relu',activity_regularizer=regularizers.activity_l1(10e-5))(input_img)

把多个自编码器叠起来即加深自编码器的深度,50个epoch后,损失val_loss:0.0926,比1个隐含层的自编码器要好一些。

  1. input_img = Input(shape=(784,))
  2. encoded = Dense(128, activation='relu')(input_img)
  3. encoded = Dense(64, activation='relu')(encoded)
  4. decoded_input = Dense(32, activation='relu')(encoded)
  5. decoded = Dense(64, activation='relu')(decoded_input)
  6. decoded = Dense(128, activation='relu')(decoded)
  7. decoded = Dense(784, activation='sigmoid')(encoded)
  8. autoencoder = Model(inputs=input_img, outputs=decoded)
  9. encoder = Model(inputs=input_img, outputs=decoded_input)
  10. autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
  11. autoencoder.fit(x_train, x_train, epochs=50, batch_size=256,
  12. shuffle=True, validation_data=(x_test, x_test))
  13. encoded_imgs = encoder.predict(x_test)
  14. decoded_imgs = autoencoder.predict(x_test)

3. 卷积自编码器:用卷积层构建自编码器

当输入是图像时,使用卷积神经网络是更好的。卷积自编码器的编码器部分由卷积层和MaxPooling层构成,MaxPooling负责空域下采样。而解码器由卷积层和上采样层构成。50个epoch后,损失val_loss: 0.1018。

  1. input_img = Input(shape=(28, 28, 1))
  2. x = Convolution2D(16, (3, 3), activation='relu', padding='same')(input_img)
  3. x = MaxPooling2D((2, 2), padding='same')(x)
  4. x = Convolution2D(8, (3, 3), activation='relu', padding='same')(x)
  5. x = MaxPooling2D((2, 2), padding='same')(x)
  6. x = Convolution2D(8, (3, 3), activation='relu', padding='same')(x)
  7. encoded = MaxPooling2D((2, 2), padding='same')(x)
  8. x = Convolution2D(8, (3, 3), activation='relu', padding='same')(encoded)
  9. x = UpSampling2D((2, 2))(x)
  10. x = Convolution2D(8, (3, 3), activation='relu', padding='same')(x)
  11. x = UpSampling2D((2, 2))(x)
  12. x = Convolution2D(16, (3, 3), activation='relu')(x)
  13. x = UpSampling2D((2, 2))(x)
  14. decoded = Convolution2D(1, (3, 3), activation='sigmoid', padding='same')(x)
  15. autoencoder = Model(inputs=input_img, outputs=decoded)
  16. autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
  17. # 打开一个终端并启动TensorBoard,终端中输入 tensorboard --logdir=/autoencoder
  18. autoencoder.fit(x_train, x_train, epochs=50, batch_size=256,
  19. shuffle=True, validation_data=(x_test, x_test),
  20. callbacks=[TensorBoard(log_dir='autoencoder')])
  21. decoded_imgs = autoencoder.predict(x_test)

4. 使用自动编码器进行图像去噪

我们把训练样本用噪声污染,然后使解码器解码出干净的照片,以获得去噪自动编码器。首先我们把原图片加入高斯噪声,然后把像素值clip到0~1。

  1. from keras.layers import Input, Convolution2D, MaxPooling2D, UpSampling2D
  2. from keras.models import Model
  3. from keras.datasets import mnist
  4. import numpy as np
  5. import matplotlib.pyplot as plt
  6. from keras.callbacks import TensorBoard
  7. (x_train, _), (x_test, _) = mnist.load_data()
  8. x_train = x_train.astype('float32') / 255.
  9. x_test = x_test.astype('float32') / 255.
  10. x_train = np.reshape(x_train, (len(x_train), 28, 28, 1))
  11. x_test = np.reshape(x_test, (len(x_test), 28, 28, 1))
  12. noise_factor = 0.5
  13. x_train_noisy = x_train + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_train.shape)
  14. x_test_noisy = x_test + noise_factor * np.random.normal(loc=0.0, scale=1.0, size=x_test.shape)
  15. x_train_noisy = np.clip(x_train_noisy, 0., 1.)
  16. x_test_noisy = np.clip(x_test_noisy, 0., 1.)
  17. print(x_train.shape)
  18. print(x_test.shape)
  19. input_img = Input(shape=(28, 28, 1))
  20. x = Convolution2D(32, (3, 3), activation='relu', padding='same')(input_img)
  21. x = MaxPooling2D((2, 2), padding='same')(x)
  22. x = Convolution2D(32, (3, 3), activation='relu', padding='same')(x)
  23. encoded = MaxPooling2D((2, 2), padding='same')(x)
  24. x = Convolution2D(32, (3, 3), activation='relu', padding='same')(encoded)
  25. x = UpSampling2D((2, 2))(x)
  26. x = Convolution2D(32, (3, 3), activation='relu', padding='same')(x)
  27. x = UpSampling2D((2, 2))(x)
  28. decoded = Convolution2D(1, (3, 3), activation='sigmoid', padding='same')(x)
  29. autoencoder = Model(inputs=input_img, outputs=decoded)
  30. autoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')
  31. # 打开一个终端并启动TensorBoard,终端中输入 tensorboard --logdir=/autoencoder
  32. autoencoder.fit(x_train_noisy, x_train, epochs=10, batch_size=256,
  33. shuffle=True, validation_data=(x_test_noisy, x_test),
  34. callbacks=[TensorBoard(log_dir='autoencoder', write_graph=False)])
  35. decoded_imgs = autoencoder.predict(x_test_noisy)
  36. n = 10
  37. plt.figure(figsize=(30, 6))
  38. for i in range(n):
  39. ax = plt.subplot(3, n, i + 1)
  40. plt.imshow(x_test[i].reshape(28, 28))
  41. plt.gray()
  42. ax.get_xaxis().set_visible(False)
  43. ax.get_yaxis().set_visible(False)
  44. ax = plt.subplot(3, n, i + 1 + n)
  45. plt.imshow(x_test_noisy[i].reshape(28, 28))
  46. plt.gray()
  47. ax.get_xaxis().set_visible(False)
  48. ax.get_yaxis().set_visible(False)
  49. ax = plt.subplot(3, n, i + 1 + 2*n)
  50. plt.imshow(decoded_imgs[i].reshape(28, 28))
  51. plt.gray()
  52. ax.get_xaxis().set_visible(False)
  53. ax.get_yaxis().set_visible(False)
  54. plt.show()

展开阅读全文

没有更多推荐了,返回首页