忘记密码   免费注册 查看新帖 | 论坛精华区

ChinaUnix.net

  平台 论坛 博客 认证专区 大话IT HPC论坛 徽章 文库 沙龙 自测 下载 频道自动化运维 虚拟化 储存备份 C/C++ PHP MySQL 嵌入式 Linux系统
最近访问板块 发新帖
查看: 1239 | 回复: 0

学习笔记TF025:自编码器 [复制链接]

论坛徽章:
0
发表于 2017-07-09 23:06 |显示全部楼层
传统机器学习依赖良好的特征工程。深度学习解决有效特征难人工提取问题。无监督学习,不需要标注数据,学习数据内容组织形式,提取频繁出现特征,逐层抽象,从简单到复杂,从微观到宏观。

稀疏编码(Sparse Coding),基本结构组合。自编码器(AutoEncoder),用自身高阶特征编码自己。期望输入/输出一致,使用高阶特征重构自己。

Hinton教授在Science发表文章《Reducing the dimensionality of data with neural networks》,讲解自编码器降维数据。基于深度信念网络(Deep Belief Networks,DBN,多层 RBN堆叠),无监督逐层训练贪心算法,逐层提取特征,极深网络权重初始化到较好位置,辅助监督训练。

1、限制中间隐含层节点数量,降维。中间隐含层权重加L1正则,根据惩罚系数控制隐含节点稀疏程度,惩罚系数越大,学到特征组合越稀疏,实际使用(非零权重)特征数量越少。
2、数据加入噪声,Denoising AutoEncoder(去噪自编码器),从噪声学习数据特征。学习数据频繁出现模式结构,略去无规律噪声。加性高斯噪声(Additive Gaussian Noise,AGN)。Nasking Noise,随机遮挡噪声,部分图像像素置0,从其他像素结构推测被遮挡像素。

一隐含层自动编码器类似主成分分析(PCA)。Hinton DBN 多个隐含层,每个隐含层是限制性玻尔兹曼机 RBM(Restricted Bltzman Machine,特殊连接分布神经网络)。先对每两层无监督预训练(pre-training),多层自编码器,网络权重初始化到理想分布。通过反向传播算法调整模型权重,使用经过标注信息做监督分类训练。解决梯度弥散(Gradient vanishment)。

去噪自编码器使用范围最广最通用。无噪声自编码器,去掉噪声,保证隐含层节点小于输入层节点。Masking Noise自编码器,高斯噪声改为随机遮挡噪声。Variational AutoEncoder(VAE),对中间节点分布强假设,有额外损失项,用特殊SGVB(Stochastic Gradient Variational Bayes)算
法训练。

先导入常用库NumPy,Scikit-lean preprocessing模块(数据预处理、标准化)。MNIST数据加载模块。

Xavier initialization 参数初始化方法,根据网络输入、输出节点数量自动调整最合适分布。Xaiver Glorot和Yoshua Bengio提出,深度学习模型权重初始化太小,信号在每层传递逐渐缩小,失效;初始化太大,逐渐放大,发散、失效。Xavier初始化器,权重满足0均值,方法为2/(nin+nout),分布用均匀分布或高斯分布。tf.random_uniform创建均匀分布,fan_in输入节点数量,fan_out输出节点数量。

去噪自编码类,初始化函数__init__()。输入,n_input(输入变量数),n_hidden(隐含层节点数),transfer_function(隐含层激活函数,默认softplus),optimizer(优化器,默认Adam),scale(高斯噪声系数,默认0.1)。

网络结构,输入x创建维度n_input placeholder。建立提取特征隐含层,输入x加噪声self.x+scale*tf.random_normal((n_input,)),tf.matmul相乘噪声输入和隐含层权重,tf.add加隐含偏置,self.transfer结果激活函数。输出层数据复原、重建,建立reconstruction层,隐含层输出self.hidden乘输出层权重,加输出层偏置。

自编码器损失函数,平方误差(Squared Error)作cost,tf.subtract计算输出(self.reconstruction)与输入(self.x)差,tf.pow求差平方,tf.reduce_sum求和。优化器self.optimizer优化损失self.cost。创建Session,初始化自编码器全部模型参数。

参数初始化函数_initialize_weights,创建all_weights字典dict,权重、偏置存入,返回all_weights。隐含层权重用xavier_init函数初始化,传入输入节点数、隐含层节点数,xavier返回适合softplus激活函数权重初始分布。隐含层偏置用tf.zeros全部置0。输出层self.reconstruction,权重、偏置都置为0。

函数partial_fit用batch数据训练返回当前损失cost。Session执行损失cost、训练过程optimizer计算图节点,输入feed_dict包括输入数据x,噪声系数scale。

求损失cost函数calc_total_cost,Session执行计算图节点self.cost,传入输入数据x,噪声系数scale,在测试集评测模型性能。

Transform函数,返回自编码器隐含层输出结果。提供获取抽象特征,自编码器隐含层最主要功能是学习出数据高阶特征。

Generate函数,隐含层输出结果为输入,复原重建层提取高阶特征为原始数据。

Reconstruct函数,整体运行复原过程,提取高阶特征,再复原数据,transform和generate,输入原始数据,输出复原数据。

GetWeights函数获取隐含层权重。

GetBiases函数获取隐含层偏置系数。

TensorFlow读取示例数据函数输入MNIST数据集。

定义训练、测试数据标准化处理函数。标准化,数据变成0均值且标准差1的分布。先减去均值,再除以标准差。sklearn.preprossing StandardScaler 类,训练集上fit,在训练数据和测试数据上必须用相同的Scaler。

获取随机block数据函数,取从0到len(data)-batch_size随机整数,作为block起始位置,顺序取batch size数据,不放回抽样。

用standard_scale函数标准化交换训练集和测试集。

定义总训练样本数,最大训练轮数(epoch)20,batch_size 128,每隔一轮(epoch)显示一次损失cost。

创建AGN自编码器实例,定义模型输入节点数n_input 784,自编码器隐含节点数n_hidden 200,隐含层激活函数transfer_function softplus,优化器optimizer Adam,学习速率 0.001,噪声系数scale 0.001。

每一轮循环开始,平均损失avg_cost设0,计算总共需要batch数(样本总数除batch大小),不放回抽样,不能保证每个样本都被抽到参与训练。每个batch循环,用get_random_block_from_data函数随机抽取block数据,用partial_fit训练batch数据,计算当前cost,整合到avg_cost。每轮迭代显示当前迭代数和本轮平均cost。

性能测试,用cal_total_cost测试测试集X_test,评价指标平方误差。

  1. import numpy as np
  2.     import sklearn.preprocessing as prep
  3.     import tensorflow as tf
  4.     from tensorflow.examples.tutorials.mnist import input_data
  5.     def xavier_init(fan_in, fan_out, constant = 1):
  6.         low = -constant * np.sqrt(6.0 / (fan_in + fan_out))
  7.         high = constant * np.sqrt(6.0 / (fan_in + fan_out))
  8.         return tf.random_uniform((fan_in, fan_out),
  9.                              minval = low, maxval = high,
  10.                              dtype = tf.float32)
  11.     class AdditiveGaussianNoiseAutoencoder(object):
  12.         def __init__(self, n_input, n_hidden, transfer_function = tf.nn.softplus, optimizer = tf.train.AdamOptimizer(),
  13.                  scale = 0.1):
  14.             self.n_input = n_input
  15.             self.n_hidden = n_hidden
  16.             self.transfer = transfer_function
  17.             self.scale = tf.placeholder(tf.float32)
  18.             self.training_scale = scale
  19.             network_weights = self._initialize_weights()
  20.             self.weights = network_weights
  21.             # model
  22.             self.x = tf.placeholder(tf.float32, [None, self.n_input])
  23.             self.hidden = self.transfer(tf.add(tf.matmul(self.x + scale * tf.random_normal((n_input,)),
  24.                 self.weights['w1']),
  25.                 self.weights['b1']))
  26.             self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])
  27.             # cost
  28.             self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(self.reconstruction, self.x), 2.0))
  29.             self.optimizer = optimizer.minimize(self.cost)
  30.             init = tf.global_variables_initializer()
  31.             self.sess = tf.Session()
  32.             self.sess.run(init)
  33.         def _initialize_weights(self):
  34.             all_weights = dict()
  35.             all_weights['w1'] = tf.Variable(xavier_init(self.n_input, self.n_hidden))
  36.             all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden], dtype = tf.float32))
  37.             all_weights['w2'] = tf.Variable(tf.zeros([self.n_hidden, self.n_input], dtype = tf.float32))
  38.             all_weights['b2'] = tf.Variable(tf.zeros([self.n_input], dtype = tf.float32))
  39.             return all_weights
  40.         def partial_fit(self, X):
  41.             cost, opt = self.sess.run((self.cost, self.optimizer), feed_dict = {self.x: X,
  42.                                                                             self.scale: self.training_scale
  43.                                                                             })
  44.             return cost
  45.         def calc_total_cost(self, X):
  46.             return self.sess.run(self.cost, feed_dict = {self.x: X,
  47.                                                      self.scale: self.training_scale
  48.                                                      })
  49.         def transform(self, X):
  50.             return self.sess.run(self.hidden, feed_dict = {self.x: X,
  51.                                                        self.scale: self.training_scale
  52.                                                        })
  53.         def generate(self, hidden = None):
  54.             if hidden is None:
  55.                 hidden = np.random.normal(size = self.weights["b1"])
  56.             return self.sess.run(self.reconstruction, feed_dict = {self.hidden: hidden})
  57.         def reconstruct(self, X):
  58.             return self.sess.run(self.reconstruction, feed_dict = {self.x: X,
  59.                                                                self.scale: self.training_scale
  60.                                                                })
  61.         def getWeights(self):
  62.             return self.sess.run(self.weights['w1'])
  63.         def getBiases(self):
  64.             return self.sess.run(self.weights['b1'])
  65.          
  66.     mnist = input_data.read_data_sets('MNIST_data', one_hot = True)
  67.     def standard_scale(X_train, X_test):
  68.         preprocessor = prep.StandardScaler().fit(X_train)
  69.         X_train = preprocessor.transform(X_train)
  70.         X_test = preprocessor.transform(X_test)
  71.         return X_train, X_test
  72.     def get_random_block_from_data(data, batch_size):
  73.         start_index = np.random.randint(0, len(data) - batch_size)
  74.         return data[start_index:(start_index + batch_size)]
  75.     X_train, X_test = standard_scale(mnist.train.images, mnist.test.images)
  76.     n_samples = int(mnist.train.num_examples)
  77.     training_epochs = 20
  78.     batch_size = 128
  79.     display_step = 1
  80.     autoencoder = AdditiveGaussianNoiseAutoencoder(n_input = 784,
  81.                                                n_hidden = 200,
  82.                                                transfer_function = tf.nn.softplus,
  83.                                                optimizer = tf.train.AdamOptimizer(learning_rate = 0.001),
  84.                                                scale = 0.01)
  85.     for epoch in range(training_epochs):
  86.         avg_cost = 0.
  87.         total_batch = int(n_samples / batch_size)
  88.         # Loop over all batches
  89.         for i in range(total_batch):
  90.             batch_xs = get_random_block_from_data(X_train, batch_size)
  91.             # Fit training using batch data
  92.             cost = autoencoder.partial_fit(batch_xs)
  93.             # Compute average loss
  94.             avg_cost += cost / n_samples * batch_size
  95.         # Display logs per epoch step
  96.         if epoch % display_step == 0:
  97.             print("Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost))
  98.     print("Total cost: " + str(autoencoder.calc_total_cost(X_test)))
复制代码


参考资料:
《TensorFlow实践》

欢迎付费咨询(150元每小时),我的微信:qingxingfengzi

您需要登录后才可以回帖 登录 | 注册

本版积分规则

  

北京盛拓优讯信息技术有限公司. 版权所有 京ICP备16024965号 北京市公安局海淀分局网监中心备案编号:11010802020122
广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员  联系我们:
感谢所有关心和支持过ChinaUnix的朋友们 转载本站内容请注明原作者名及出处

清除 Cookies - ChinaUnix - Archiver - WAP - TOP