自编码器论文的提出是为了神经网络权重更好的初始化，他将多层网络一层一层的通过自编码器确定初始权重，最终再对模型进行权重训练；
这种初始化权重的方式目前已经不是主流，但他的思路可以借鉴到很多场景；
模型简介
自编码器，AutoEncode，它分为两部分，前一部分是编码器，后一部分是解码器，
它的原理非常简单，就是把输入 通过编码器编码，然后再通过解码器解码，使得解码后的数据与输入尽可能一致；
它的输入输出都是数据本身，如图
由于自编码器算法没有用到 数据的 label，所以可以视为一种无监督学习
自编码器种类
自编码器有很多种，区别在于
1. 网络结构不同：全连接、卷积，深层、浅层
2. 给自编码器网络加上一些约束，使得输入与输出不完全一致，只近似的复制输入，这样我们可以实现优先复制数据的部分特征
栈式自编码器
很简单，就是多隐层的网络，如图
注意：网络不要太深，过深的网络也是能够解码成原图的，但是把图像压缩得很小，比如一个数，这对于其他应用，比如特征提取，没什么意义了，压缩太狠了
不完备自编码器
输入维数大于编码后的维数，也就是降维，类似于 PCA，但效果比 PCA 好
去燥自编码器
输入有噪声的图像，训练的 ‘label’ 为无噪声的图像，实现图像去燥
使用场景
通常情况下，自编码器网络训练好之后，我们只取编码器部分的权重；
特征提取
由于编码后的特征能够通过某种方式解码成原始数据，说明该特征能够很好的代表原始数据，
降维
一般情况下，输入的维度会大于编码后的维度，这达到降维的作用
图像降噪
输入有噪声的图像，模型的 ‘label’ 是无噪声的图像
图像压缩
图像太大，输入维度过高，模型收敛慢，且从过多信息中学习特征是比较困难的，压缩之后轻松愉快
算法特点
1. 有损压缩：压缩后的信息少于原始信息，且不可恢复
2. 数据相关：自编码器模型只适用于和训练数据相关的数据，比如人脸的自编码器不能用于汽车
示例
import numpy as np import sklearn.preprocessing as prep import tensorflow as tf from tensorflow.examples.tutorials.mnist import input_data # xavier initializaton参数初始化方法 def xavier_init(fan_in, fan_out, constant=1): low = -constant * np.sqrt(6.0/(fan_in+fan_out)) high = constant * np.sqrt(6.0/(fan_in+fan_out)) return tf.random_uniform((fan_in, fan_out), minval=low, maxval=high, dtype=tf.float32) class AdditiveGaussianNoiseAutoEncoder(object): def __init__(self, n_input, n_hidden ,transfer_function=tf.nn.softplus, optimizer=tf.train.AdamOptimizer(), scale=0.1): # 1，定义一些必需的参数 self.n_input = n_input # 输入 self.n_hidden = n_hidden # self.transfer = transfer_function self.scale = tf.placeholder(tf.float32) self.training_scale = scale networks_weights = self._initialize_weigths() self.weights = networks_weights # 2，定义网络结构 三层网络 self.x = tf.placeholder(tf.float32, [None, self.n_input]) # 图片拉成一维 # 隐层输出：activeFunc((x+noise)*w1+b1) self.hidden = self.transfer(tf.add(tf.matmul(self.x + scale * tf.random_normal((n_input,)) , self.weights['w1']), self.weights['b1'])) # output：hidden*w2+b2 self.reconstruction = tf.matmul(self.hidden,self.weights['w2'])+self.weights['b2'] # 3，定义损失函数和优化器 ### self.reconstruction-self.x 解码后的图像-原图 self.cost = 0.5 * tf.reduce_sum(tf.pow((self.reconstruction - self.x), 2.0)) / 128 self.optimizer = optimizer.minimize(self.cost) # 4，全局参数初始化 init = tf.global_variables_initializer() self.sess = tf.Session() self.sess.run(init) def _initialize_weigths(self): all_weigths = dict() all_weigths['w1'] = tf.Variable(xavier_init(self.n_input,self.n_hidden),dtype=tf.float32) all_weigths['b1'] = tf.Variable(tf.zeros([self.n_hidden],dtype=tf.float32)) all_weigths['w2'] = tf.Variable(tf.zeros([self.n_hidden,self.n_input]),dtype=tf.float32) all_weigths['b2'] = tf.Variable(tf.zeros([self.n_input],dtype=tf.float32)) return all_weigths def partial_fit(self, X): # 当前 cost cost,opt = self.sess.run([self.cost, self.optimizer], feed_dict={self.x:X, self.scale:self.training_scale}) ### 两个 placeholder，x scale return cost def calc_total_cost(self,X): # 计算cost,用来测试模型效果 return self.sess.run(self.cost, feed_dict={self.x:X,self.scale:self.training_scale}) def transform(self,X): # 编码 return self.sess.run(self.hidden, feed_dict={self.x:X,self.scale:self.training_scale}) def generate(self,hidden=None): # 解码 if hidden==None: hidden = np.random.normal(size = self.weigths['b1']) return self.sess.run(self.reconstruction,feed_dict={self.hiddne:hidden}) # 重构，包括编码和解码两个过程 def reconstruct(self, X): return self.sess.run(self.reconstruction, feed_dict={self.x:X, self.scale:self.training_scale}) def getWeights(self): return self.sess.run(self.weights['w1']) def getBiases(self): return self.sess.run(self.weights['b1']) def pltTwo(self): import matplotlib.pyplot as plt r = np.random.randint(0, mnist.test.num_examples - 1) fig = plt.figure() ax = fig.add_subplot(131) bx = fig.add_subplot(132) cx = fig.add_subplot(133) ax.imshow(mnist.test.images[r:r + 1].reshape(28, 28), cmap='Greys', interpolation='nearest') ### 随机选一张图，reshape bx.imshow(self.transform(mnist.test.images[r:r + 1]).reshape(20, 20), cmap='Greys', interpolation='nearest') ### 编码 cx.imshow(self.reconstruct(mnist.test.images[r:r + 1]).reshape(28, 28), cmap='Greys', interpolation='nearest') ### 编码解码形成新图 plt.show() # 数据标准化 def standard_scale(X_train,X_test): preprocessor = prep.StandardScaler().fit(X_train) X_train = preprocessor.transform(X_train) X_test = preprocessor.transform(X_test) return X_train,X_test def get_random_block_form_data(data, batch_size): # 获取随机block数据 start_index = np.random.randint(0, len(data)-batch_size) return data[start_index:(start_index + batch_size)] if __name__=='__main__': # 1，获取数据并标准化 # mnist = input_data.read_data_sets("./data", one_hot=True) mnist = input_data.read_data_sets("./data", one_hot=True) ### 获取数据 X_train,X_test = standard_scale(mnist.train.images,mnist.test.images) ### 数据标准化 # 2，定义一些训练参数 n_samples = int(mnist.train.num_examples) training_epochs = 100 batch_size = 128 display_step = 2 # 3，构建去噪自编码器模型，包括网络结构的定义，loss和优化器的定义等 autoencoder = AdditiveGaussianNoiseAutoEncoder(n_input=784, n_hidden=400, ### 这里设 400 是为了 编码图片为 400 维，可以 reshape 成 20x20 transfer_function=tf.nn.softplus, optimizer=tf.train.AdamOptimizer(learning_rate=0.001), scale=0.01) # 4，迭代训练 for epoch in range(training_epochs): avg_cost = 0.0 total_batch = int(n_samples/batch_size) ### 所有样本迭代完毕需要的 次数 for i in range(total_batch): batch_xs = get_random_block_form_data(X_train,batch_size) ### 随机获取一个 batch 的数据，可能有大量重复 cost = autoencoder.partial_fit(batch_xs) ### 当前 cost avg_cost += cost/n_samples if epoch % display_step == 0: print('Epoch: %04d,cost=%.9f' % (epoch+1,avg_cost)) # 5，测试 print('Total cost: '+str(autoencoder.calc_total_cost(X_test))) # 6,原始图和重构图的对比 autoencoder.pltTwo()
输出：原始图；编码图；解码图
只是个 demo，自己可以调试下
参考资料：
https://www.cnblogs.com/LXP-Never/p/10921257.html
https://www.cnblogs.com/virter/p/9547520.html
https://www.cnblogs.com/royhoo/p/Autoencoders.html
https://zhuanlan.zhihu.com/p/80377698