# -*- coding: utf-8 -*-
"""
Created on Fri Apr 27 09:52:50 2018
@author: Administrator
"""
#导入所需要的库,这里采用手写数字
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
"""
Xaiver初始化器做的事情就是让权重被初始化的不大不小,正好适合
从数学角度分析,Xavier就是让权证满足0均值,同时方差为2/(in +out)分布可以利用均匀分布或高斯分布
这里利用tf.random_uniform创建了一个均匀分布
"""
def xavier_init(fan_in,fan_out,constant = 1): #fan_in,fan_out是输入、输出节点数量
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,#方差为(max-min)^2/12
dtype = tf.float32)
#定义一个去噪自编码的class
class AdditiveGaussianNoiseAutoencoder(object):
"""
__init__()函数包含这样几个输入:n_input(输入变量数)
n_hidden(隐含层节点数)、transfer_function(隐含层激活函数,默认是softplus)、
optimizer(优化器,默认为Adama),scale(高斯噪声系数,默认值为0.1)
其中class内的scale参数做成了一个placeholder,参数初始化则使用了接下来定义的_initialize_weights函数
"""
def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus,
optimizer = tf.train.AdamOptimizer(),scale = 0.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
network_weights = self._initializer_weights()
self.weights = network_weights
"""
接下来开始定义网络结构,为输入x创建一个维度为n_input的placeholder
然后建立一个能提取特征的隐含层,先将输入x加上噪声,然后用tf.matmul将加入了噪声的
输入与隐含层的权重w1相乘,并使用tf.add加上隐含层的偏置b1,最后使用self.transfer
对结果进行激活函数处理。经过隐含层后,需要在输出层进行数据复原、重建操作(即建立reconstruction
),这里不需要激活函数,直接将隐含层的输出self.hidden乘上输出层的权重w2,再加上偏置b2
"""
self.x = tf.placeholder(tf.float32,[None,self.n_input])
self.hidden = self.transfer(tf.add(tf.matmul(
self.x+scale*tf.random_normal((n_input,)),
self.weights['w1']),self.weights['b1']))
self.reconstruction = tf.add(tf.matmul(self.hidden,self.weights['w2']),
self.weights['b2'])
"""
接下来定义自编码的损失函数,直接使用平方误差作为cost,
即用tf.subtract计算输出(self.reconstruction)
与输入(self.x)只差,在使用tf.pow求差的平方,
最后使用tf.reduce_sum求和即可得到平方误差
self.optimizer对损失self.cost进行优化
并初始化自编码器的全部模型参数 """
self.cost = 0.5*tf.reduce_sum(tf.pow(tf.subtract(
self.reconstruction,self.x),2.0))
self.optimizer = optimizer.minimize(self.cost)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
"""参数初始化函数_initialize_weights
先创建一个字典all_weights的dict,然后将w1,b1,w2,b2全部存入其中
"""
def _initializer_weights(self):
all_weights = dict()
"""w1需要使用前面定义的xavier_init函数初始化,直接传入输入节点数和隐含层节点数,
然后xavier即可返回一个比较合适的softplus等激活函数的权重初始分布"""
all_weights['w1'] = tf.Variable(xavier_init(self.n_input,
self.n_hidden))
"""偏置b1只需要使用tf.zeros全部置为0"""
all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden],dtype = tf.float32))
"""输出层没有激活函数,于是将w2,b2全部初始化为0"""
all_weights['w2'] = tf.Variable(tf.zeros([self.n_hidden,
self.n_input],dtype = tf.float32))
all_weights['b2'] = tf.Variable(tf.zeros([self.n_input],dtype = tf.float32))
return all_weights
"""定义损失cost及执行一步训练的函数partial_fit。
函数只需让Session执行两个计算图的节点,分别是cost和训练过程optimizer,
输入的feed_dict包括输入数据x,以及噪声系数scale
函数pertial_fit做的就是用一个batch诗句进行训练并返回当前的损失"""
def partial_fit(self,X):
cost,opt = self.sess.run((self.cost,self.optimizer),
feed_dict = {self.x:X,self.scale:self.training_scale})
return cost
"""需要一个只求cost的函数calc_tatol_cost,这里只让Session执行一个计算节点self.cost,
传入的参数与前面的partial_fit一致。这个函数是在自编码器训练完毕后,
在测试集上对模型性能进行评测是会用到它,他不会想partial_fit那样触发训练操作"""
def calc_total_cost(self,X):
return self.sess.run(self.cost,feed_dict = {self.x:X,
self.scale:self.training_scale})
"""定义transfer函数,它返回自编码器隐含层的输出结果。
它的目的是提供一个接口来获取抽象后的特征,
自编码器的隐含层的最主要功能就是学习出数据中的高阶特征"""
def transform(self,X):
return self.sess.run(self.hidden,feed_dict = {self.x:X,
self.scale:self.training_scale})
"""定义generate函数,将隐含层的输出结果作为输入通过之后的重建层将提取到的
高阶特征复原为原始数据。这个接口和前面的transfer正好将整个自编码器拆分为两部分,
这里是generate接口是后半部分,将高阶特征复原为原始数据的步骤"""
def generate(self,hidden = None):
if hidden is None:
hidden = np.random.normal(size = self.weights['b1'])
return self.sess.run(self.reconstruction,
feed_dict = {self.hidden:hidden})
"""定义reconstruct函数,整体运行一遍复原过程,包括提取高阶特征和通过高阶特征复原数据,
即包括transfer和generate两块。输入数据是原数据,输出数据是复原后的数据"""
def reconstruct(self,X):
return self.sess.run(self.reconstruction,feed_dict = {self.x:X,
self.scale:self.training_scale})
"""getWeights函数作用是获取隐含层的权重w1"""
def getWeights(self):
return self.sess.run(self.weights['w1'])
"""getBiases函数则是获取隐含层的偏置系数b1"""
def getBiases(self):
return self.sess.run(self.weights['b1'])
"""载入MNIST"""
mnist = input_data.read_data_sets('MNIST_data',one_hot = True)
"""
定义一个对训练、测试数据进行标准化处理的函数。标准化即让数据变成0均值,
且标准差为1的分布。方法是先减去均值,再除以标准差。直接使用sklearn.preprossing的
StandardScaler这个类,先在训练集上进行fit,再将这个Scaler用到训练数据和测试数据上。"""
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
"""在定义一个获取随机block数据的函数:取一个从0到len(data)-batch_size之间的随机整数,
再以这个随机数作为block的起始位置,然后顺序取到一个batch_size的数据。
需要注意的是,这属于不放回抽样,可以提高数据的利用率"""
def get_random_block_from_data(data,batch_size):
start_index = np.random.randint(0,len(data)-batch_size)
return data[start_index:(start_index + batch_size)]
"""使用之前定义的standard_scale函数对训练集、测试集进行标准化变换"""
X_train,X_test = standard_scale(mnist.train.images,mnist.test.images)
n_samples = int(mnist.train.num_examples)
training_epochs = 20 #最大训练的轮数
batch_size = 128
display_step = 1
autoencoder = AdditiveGaussianNoiseAutoencoder(
n_input = 784, #模型输入节点数
n_hidden = 200, #隐含层节点数200
transfer_function = tf.nn.softplus, #隐含层的激活函数softplus
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001), #学习速率为0.001
scale = 0.01) #噪声的系数为scale设为0.01
for epoch in range(training_epochs):
avg_cost = 0. #平均损失
total_batch = int(n_samples/batch_size) #计算总共需要的batch数
for i in range(total_batch):
batch_xs = get_random_block_from_data(X_train,batch_size)#随机抽取一个block的数据
cost = autoencoder.partial_fit(batch_xs)#训练这个batch的数据并计算当前的cost
avg_cost +=cost/n_samples * batch_size #将当前的cost整合到avg_cost中
if epoch % display_step == 0:
print ("Epoch:", '%04d' % (epoch+1),
"cost=" ,"{:.9f}".format(avg_cost))
print ("Total cost:" + str(autoencoder.calc_total_cost(X_test)))
"""
Created on Fri Apr 27 09:52:50 2018
@author: Administrator
"""
#导入所需要的库,这里采用手写数字
import numpy as np
import sklearn.preprocessing as prep
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
"""
Xaiver初始化器做的事情就是让权重被初始化的不大不小,正好适合
从数学角度分析,Xavier就是让权证满足0均值,同时方差为2/(in +out)分布可以利用均匀分布或高斯分布
这里利用tf.random_uniform创建了一个均匀分布
"""
def xavier_init(fan_in,fan_out,constant = 1): #fan_in,fan_out是输入、输出节点数量
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,#方差为(max-min)^2/12
dtype = tf.float32)
#定义一个去噪自编码的class
class AdditiveGaussianNoiseAutoencoder(object):
"""
__init__()函数包含这样几个输入:n_input(输入变量数)
n_hidden(隐含层节点数)、transfer_function(隐含层激活函数,默认是softplus)、
optimizer(优化器,默认为Adama),scale(高斯噪声系数,默认值为0.1)
其中class内的scale参数做成了一个placeholder,参数初始化则使用了接下来定义的_initialize_weights函数
"""
def __init__(self,n_input,n_hidden,transfer_function=tf.nn.softplus,
optimizer = tf.train.AdamOptimizer(),scale = 0.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
network_weights = self._initializer_weights()
self.weights = network_weights
"""
接下来开始定义网络结构,为输入x创建一个维度为n_input的placeholder
然后建立一个能提取特征的隐含层,先将输入x加上噪声,然后用tf.matmul将加入了噪声的
输入与隐含层的权重w1相乘,并使用tf.add加上隐含层的偏置b1,最后使用self.transfer
对结果进行激活函数处理。经过隐含层后,需要在输出层进行数据复原、重建操作(即建立reconstruction
),这里不需要激活函数,直接将隐含层的输出self.hidden乘上输出层的权重w2,再加上偏置b2
"""
self.x = tf.placeholder(tf.float32,[None,self.n_input])
self.hidden = self.transfer(tf.add(tf.matmul(
self.x+scale*tf.random_normal((n_input,)),
self.weights['w1']),self.weights['b1']))
self.reconstruction = tf.add(tf.matmul(self.hidden,self.weights['w2']),
self.weights['b2'])
"""
接下来定义自编码的损失函数,直接使用平方误差作为cost,
即用tf.subtract计算输出(self.reconstruction)
与输入(self.x)只差,在使用tf.pow求差的平方,
最后使用tf.reduce_sum求和即可得到平方误差
self.optimizer对损失self.cost进行优化
并初始化自编码器的全部模型参数 """
self.cost = 0.5*tf.reduce_sum(tf.pow(tf.subtract(
self.reconstruction,self.x),2.0))
self.optimizer = optimizer.minimize(self.cost)
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
"""参数初始化函数_initialize_weights
先创建一个字典all_weights的dict,然后将w1,b1,w2,b2全部存入其中
"""
def _initializer_weights(self):
all_weights = dict()
"""w1需要使用前面定义的xavier_init函数初始化,直接传入输入节点数和隐含层节点数,
然后xavier即可返回一个比较合适的softplus等激活函数的权重初始分布"""
all_weights['w1'] = tf.Variable(xavier_init(self.n_input,
self.n_hidden))
"""偏置b1只需要使用tf.zeros全部置为0"""
all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden],dtype = tf.float32))
"""输出层没有激活函数,于是将w2,b2全部初始化为0"""
all_weights['w2'] = tf.Variable(tf.zeros([self.n_hidden,
self.n_input],dtype = tf.float32))
all_weights['b2'] = tf.Variable(tf.zeros([self.n_input],dtype = tf.float32))
return all_weights
"""定义损失cost及执行一步训练的函数partial_fit。
函数只需让Session执行两个计算图的节点,分别是cost和训练过程optimizer,
输入的feed_dict包括输入数据x,以及噪声系数scale
函数pertial_fit做的就是用一个batch诗句进行训练并返回当前的损失"""
def partial_fit(self,X):
cost,opt = self.sess.run((self.cost,self.optimizer),
feed_dict = {self.x:X,self.scale:self.training_scale})
return cost
"""需要一个只求cost的函数calc_tatol_cost,这里只让Session执行一个计算节点self.cost,
传入的参数与前面的partial_fit一致。这个函数是在自编码器训练完毕后,
在测试集上对模型性能进行评测是会用到它,他不会想partial_fit那样触发训练操作"""
def calc_total_cost(self,X):
return self.sess.run(self.cost,feed_dict = {self.x:X,
self.scale:self.training_scale})
"""定义transfer函数,它返回自编码器隐含层的输出结果。
它的目的是提供一个接口来获取抽象后的特征,
自编码器的隐含层的最主要功能就是学习出数据中的高阶特征"""
def transform(self,X):
return self.sess.run(self.hidden,feed_dict = {self.x:X,
self.scale:self.training_scale})
"""定义generate函数,将隐含层的输出结果作为输入通过之后的重建层将提取到的
高阶特征复原为原始数据。这个接口和前面的transfer正好将整个自编码器拆分为两部分,
这里是generate接口是后半部分,将高阶特征复原为原始数据的步骤"""
def generate(self,hidden = None):
if hidden is None:
hidden = np.random.normal(size = self.weights['b1'])
return self.sess.run(self.reconstruction,
feed_dict = {self.hidden:hidden})
"""定义reconstruct函数,整体运行一遍复原过程,包括提取高阶特征和通过高阶特征复原数据,
即包括transfer和generate两块。输入数据是原数据,输出数据是复原后的数据"""
def reconstruct(self,X):
return self.sess.run(self.reconstruction,feed_dict = {self.x:X,
self.scale:self.training_scale})
"""getWeights函数作用是获取隐含层的权重w1"""
def getWeights(self):
return self.sess.run(self.weights['w1'])
"""getBiases函数则是获取隐含层的偏置系数b1"""
def getBiases(self):
return self.sess.run(self.weights['b1'])
"""载入MNIST"""
mnist = input_data.read_data_sets('MNIST_data',one_hot = True)
"""
定义一个对训练、测试数据进行标准化处理的函数。标准化即让数据变成0均值,
且标准差为1的分布。方法是先减去均值,再除以标准差。直接使用sklearn.preprossing的
StandardScaler这个类,先在训练集上进行fit,再将这个Scaler用到训练数据和测试数据上。"""
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
"""在定义一个获取随机block数据的函数:取一个从0到len(data)-batch_size之间的随机整数,
再以这个随机数作为block的起始位置,然后顺序取到一个batch_size的数据。
需要注意的是,这属于不放回抽样,可以提高数据的利用率"""
def get_random_block_from_data(data,batch_size):
start_index = np.random.randint(0,len(data)-batch_size)
return data[start_index:(start_index + batch_size)]
"""使用之前定义的standard_scale函数对训练集、测试集进行标准化变换"""
X_train,X_test = standard_scale(mnist.train.images,mnist.test.images)
n_samples = int(mnist.train.num_examples)
training_epochs = 20 #最大训练的轮数
batch_size = 128
display_step = 1
autoencoder = AdditiveGaussianNoiseAutoencoder(
n_input = 784, #模型输入节点数
n_hidden = 200, #隐含层节点数200
transfer_function = tf.nn.softplus, #隐含层的激活函数softplus
optimizer = tf.train.AdamOptimizer(learning_rate = 0.001), #学习速率为0.001
scale = 0.01) #噪声的系数为scale设为0.01
for epoch in range(training_epochs):
avg_cost = 0. #平均损失
total_batch = int(n_samples/batch_size) #计算总共需要的batch数
for i in range(total_batch):
batch_xs = get_random_block_from_data(X_train,batch_size)#随机抽取一个block的数据
cost = autoencoder.partial_fit(batch_xs)#训练这个batch的数据并计算当前的cost
avg_cost +=cost/n_samples * batch_size #将当前的cost整合到avg_cost中
if epoch % display_step == 0:
print ("Epoch:", '%04d' % (epoch+1),
"cost=" ,"{:.9f}".format(avg_cost))
print ("Total cost:" + str(autoencoder.calc_total_cost(X_test)))