Tensorflow基于minist数据集实现自编码器

快来打我* 2023-06-06 04:57 42阅读 0赞

### Tensorflow实现自编码器 ###

*  自编码器
 *   *  Denoising AutoEncoder(去噪自编码器)

# 自编码器 #

特征的稀疏表达：使用少量的基本特征组合拼装得到更高层抽象的特征。  
如：图像碎片可由少量的基本结构稀疏表达。

自编码器定义：

*  使用自身的高阶特征编码自己，目标是使用稀疏的一些高阶特征重新组合来重构自己。

自编码器特点：

*  输入节点和输出节点的数量一致
 *  使用自身的高阶特征编码自己，不只是复制像素点

自编码器作用：

*  给监督训练做无监督的预训练，提取特征
 *  可直接进行特征提取和分析

自编码器使用少量稀疏的高阶特征来重构输入，所以加入几种限制：

*  如果限制隐含层的数量，中间隐含层节点数量小于输入输出节点数量，相当于**降维**的过程，只能**学习输入数据最重要的特征**，将不太相关的内容去除。
 *  如果给数据加噪声（通常是加性高斯噪声Additive Gaussian Noise,AGN），那么就是Denoising AutoEncoder(去噪自编码器)，将从噪声中学习出数据的特征，学习数据频繁出现的模式和结构，将无规律的噪声去除。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]

## Denoising AutoEncoder(去噪自编码器) ##

"""
        作者：Heart Sea
        功能：tessorflow实现去噪自编码器Additive Gaussian Noise,AGN
        Model:
            1个输入层, 加噪声
            全连接
            1个隐含层, 激活
            全连接
            1个输出层
        版本：1.0
        日期：10/10/2019
    """
    
    import numpy as np                       # 导入常用库numpy
    import sklearn.preprocessing as prep     # 导入sklearn中的preprocessing模块，负责预处理数据标准化
    import tensorflow as tf                  # 导入tensorflow
    from tensorflow.examples.tutorials.mnist import input_data    # 导入mnist数据集
    
    
    # 实现标准均匀分布的Xaiver初始化器(根据某一层网络的输入、输出节点数量自动调整最合适的权重分布)
    # Xaiver就是让权值满足：均值=0，方差=2/(n_in+n_out)
    # 分布可以用均匀分布或者高斯分布,这里采用均匀分布，方差=2/(n_in+n_out)=（max-min）^2/12
    def xavier_init_(fan_in, fan_out, constant=1):  # xavier_init_(self.n_input, self.n_hidden)
        """
        :param fan_in: 输入节点的数量, 行数
        :param fan_out: 输出节点的数量, 列数
        :param constant: 1
        :return: 返回一个比较适合softplus等激活函数的权重初始分布w1
        """
        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，此类包括一个构建函数_init_(),还有一些成员函数
    class AdditiveGaussianNoiseAutoencoder(object):
        def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus,
                     optimizer=tf.train.AdadeltaOptimizer(), scale=0.1):
            """
            :param n_input: 输入变量数
            :param n_hidden: 隐含层节点数
            :param transfer_function: 隐含层激活函数，默认为softplus
            :param optimizer: 默认为Adam
            :param 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._initialize_weights()  # 使用_initialize_weights()函数初始化参数,后面会定义
            self.weights = network_weights
    
        # 定义网格结构：输入层，隐含层，输出层
            # x每行是一个样本，列是特征
            self.x = tf.placeholder(tf.float32, [None, self.n_input])
            # 建立能提取特征的隐含层，給输入添加维度为(n_input,)的正态分布的噪声
            # tf.random_normal((n_input,))里的小括号可换成中括号，一行n_input列个正态随机个数，没有设置随机种子
            # self.x + scale * tf.random_normal((n_input,))相当于每个样本的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，输出与输入之差再平方，求和，0.5
            self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.subtract(
                self.reconstruction, self.x), 2.0))         # 使用平方误差作为cost
            self.optimizer = optimizer.minimize(self.cost)  # 优化器为损失进行优化
    
            init = tf.global_variables_initializer()        # 初始化全部模型参数
            self.sess = tf.Session()                        # 建立Session
            self.sess.run(init)
    
        # 定义参数初始化函数_initialize_weights
        # 输出层权重和偏置不含激活函数，直接初始化为0
        def _initialize_weights(self):
            all_weights = dict()  # 创建字典dict
            all_weights['w1'] = tf.Variable(xavier_init_(self.n_input, self.n_hidden))   # 返回一个比较适合softplus等激活函数的权重初始分布
            all_weights['b1'] = tf.Variable(tf.zeros([self.n_hidden], dtype=tf.float32))
            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
    
        def partial_fit(self, X):
            """
            aim: 定义计算损失cost及执行一步训练的函数partial_fit
            :param X: 一个batch数据
            :return: 当前损失
            """
            cost, opt = self.sess.run((self.cost, self.optimizer),
                                      feed_dict={
        self.x: X, self.scale: self.training_scale})
            return cost
    
        def calc_total_cost(self, X):
            """
            aim: 定义一个只计算cost的函数，主要是在训练完毕后，在测试集上对模型性能进行测评，不会触发训练操作
            :param X: 测试集数据
            :return: 平方误差cost
            """
            return self.sess.run(self.cost, feed_dict={
        self.x: X,
                                                       self.scale: self.training_scale})
    
        def transform(self, X):
            """
            aim: 定义transform函数（自编码器的前半部分），目的是提供一个接口来获取高阶特征
            :param X:
            :return: 返回自编码器隐含层的输出结果 hidden
            """
            return self.sess.run(self.hidden, feed_dict={
        self.x: X,
                                                         self.scale: self.training_scale})
    
        def generate(self, hidden=None):
            """
            定义generate函数（自编码器的后半部分），将transform提取的高阶特征经过重建层复原为原始数据
            :param hidden: 隐含层的输出结果
            :return: 高阶特征经过重建层复原为原始数据
            """
            if hidden is None:
                hidden = np.random.normal(size=self.weights["b1"])
            return self.sess.run(self.reconstruction, feed_dict={
        self.hidden: hidden})
    
        def reconstruct(self, X):
            """
            整体运行transform和generate两个过程
            :param X: 原始数据
            :return: 复原的原始数据
            """
            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 = input_data.read_data_sets('MNIST_data', one_hot=True)   # 载入minist数据集
    
    
    # 定义standard_scale函数，对训练、测试数据标准化，
    # 标准化即让数据变成0均值，且标准差为1的分布。方法是先减去均值，再除以标准差
    # 为保证训练、测试数据使用完全相同的Scaler，需要先在训练数据上fit出一个共用的Scaler，再将这个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数据的函数
    # random.randint(a, b)，用于生成一个指定范围a <= n <= b的整数
    # 将这个随机数作为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_index函数标准化训练集，测试集
    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                           # 批数据，即多少个样本作为一个batch
    display_step = 1                           # 每隔一轮epoch显示一次损失cost
    
    # 创建一个AGN自编码器的实例，并设置输入层节点数、隐含层节点数、隐含层激活函数、优化器、噪声系数
    autoencoder = AdditiveGaussianNoiseAutoencoder(n_input=784,
                                                   n_hidden=200,
                                                   transfer_function=tf.nn.softplus,
                                                   optimizer=tf.train.AdamOptimizer(learning_rate=0.001),
                                                   scale=0.01)
    
    # 开始训练
    for epoch in range(training_epochs):                # 迭代训练轮数
        # print(epoch)
        avg_cost = 0.                                   # 每一轮开始时，平均损失=0
        total_batch = int(n_samples / batch_size)       # 样本总数/batch大小=需要的batch数
        for i in range(total_batch):                    # 迭代一轮中所有的批数据
            # print(i)
            batch_xs = get_random_block_from_data(X_train, batch_size)       # 随机抽取block数据
    
            cost = autoencoder.partial_fit(batch_xs)      # 使用partial_fit训练这个当前的batch数据的平方误差
            avg_cost += cost / n_samples * batch_size     # 将当前的cost整合到avg_cost，计算平均cost
    
    # 每一轮迭代后，显示当前的迭代数和这一轮迭代的acg_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)))

Epoch: 0001 cost= 19708.600550000  
Epoch: 0002 cost= 13143.029138636  
。  
。  
。

从实现的角度而言，自编码器其实和一个单隐含层的神经网络差不多，只是自编码器在数据输入时做了标准化处理，且加上了一个高斯噪声，同时我们的输出结果不是数字分类结果，而是复原的数据，因此不需要用标注过的数据进行监督训练。自编码器作为一种无监督学习方法，它与其他无监督学习的区别主要在于：它不是对数据进行聚类，而是把数据中最有用、最频繁的高阶特征提取出来，然后根据这些高阶特征进行重构数据。在深度学习发展早期非常流行的DBN，也是依靠这种思想，先对数据进行无监督学习，提取到一些有用的特征，将神经网络权重初始化到一个较好的分布，然后再使用有标注的数据进行监督训练，即对权重进行fine-tune。

现实生活中，大部分数据是没有标准信息的，但人脑比较擅长处理这些数据，会提取出其中的高阶抽象特征，并使用在别的地方。自编码器作为深度学习在无监督领域的应用的确非常成功，同时无监督学习也将成为深度学习一个重要发展方向。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70]: /images/20230601/375fd24ee89f4dfb922e4780d150f8de.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0hlYXJ0X1NlYQ_size_16_color_FFFFFF_t_70 1]: /images/20230601/83f94093ee6440279cf948ef24c78486.png