tensorflow 实现基本AutoEncoder,降噪自编码器

Auto-Encoder(AE)是20世纪80年代晚期提出的,它是一种无监督学习算法,使用了反向传播算法,让目标值等于输入值。基本的AE可视为一个三层神经网络结构:一个输入层、一个隐藏层和一个输出层,其中输出层与输入层具有相同的规模。

AE最初是作为一个降维手段来进行的,要是编码器那里没有使用非线性部分,那么就可以等价为PCA算法来使用。(初始的维数大于编码器输出的维数的时候)

而现在编码器的输出维数大于输入的维数(over-complete setting),获取更高维,更加有意义的表示。

AE有一个问题就是要是直接对上面的损失函数(平方误差或者交叉熵)进行训练的话,很可能就会得到一个恒等函数。解决此问题的常用的一些方法,有在损失函数里面引入稀疏性(sparse AE),或者在网络中引入随机性(如RBM,Denoising AE)。

 

标准自编码器(在基本的自编码器里面引入正则化项就行,一般是L1或者L2正则化项。)

标准自编码器实则是对权重的设置提出要求,限制权重,避免过大


tensorflow 实现基本AutoEncoder,降噪自编码器_第1张图片

最左边的是一个输入层,中间是隐藏层,最右边是输出层,输出层的神经元数量完全等于输入层神经元的数量。隐藏层的神经元数量少于输出层。 自编码网络的作用是,将输入样本压缩到隐藏层,再在输出端重建样本。其目标是使输出和输入之间尽量的小。

神经网络权重矩阵的初始化,经验之谈,xaviar initialization。如果权重初始化得太小,那信号在每层间传递是逐渐缩小而难以产生作用,但是如果权重初始化得太大,那信号将在每层间逐渐放大并且导致发散和失效。xaviar initialization就是让均值满足为0,方差是

损失函数:

实现基本自编码器

# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
import Utils

class Autoencoder(object):

    def __init__(self, n_input, n_hidden, transfer_function=tf.nn.softplus, optimizer = tf.train.AdamOptimizer()):
        # softplus: ln(exp(x) + 1) 它的倒数就是sigmoid函数,它限制左边始终大于0,右边没有限制
        self.n_input = n_input
        self.n_hidden = n_hidden
        self.transfer = transfer_function

        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        # n_input 指的是输入的维度
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        self.hidden = self.transfer(tf.add(tf.matmul(self.x, self.weights['w1']), self.weights['b1']))
        # 将隐藏层的输出限制在大于0的空间里面,
        # 这就是一个非线性环节,只限制左端,并没有限制右端
        self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])
        # 在这里重构结果,只是隐藏环节的一个线性变换,
        # 并没有加上任何非线性的环节,所以后面求重构误差的时候,
        # 直接使用均方误差就行(因为这里并没有使用非线性环节进行归一化,要是使用了,可以利用交叉熵)

        # cost
        self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.sub(self.reconstruction, self.x), 2.0))
        # 做减法,然后平方,这里使用的是重构误差最小,使用均方误差
        self.optimizer = optimizer.minimize(self.cost)

        init = tf.initialize_all_variables()
        self.sess = tf.Session()
        self.sess.run(init)


    def _initialize_weights(self):
        all_weights = dict()
        all_weights['w1'] = tf.Variable(Utils.xavier_init(self.n_input, self.n_hidden))
        # 在初始化的时候,就只是第一个权重矩阵是赋予一些随机值,其他的都是赋予全0矩阵
        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):
        cost, opt = self.sess.run((self.cost, self.optimizer), feed_dict={self.x: X})
        return cost

    def calc_total_cost(self, X):
        return self.sess.run(self.cost, feed_dict = {self.x: X})

    def transform(self, X):
        # 这个函数在整个自编码器训练好了之后,使用它可以将原始数据进行编码,得到的结果就是编码形式
        return self.sess.run(self.hidden, feed_dict={self.x: X})

    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})

    def reconstruct(self, X):
        # 先进行编码,然后进行解码,得到的最后结果
        return self.sess.run(self.reconstruction, feed_dict={self.x: X})

    def getWeights(self):
        # 得到编码用的权值矩阵
        return self.sess.run(self.weights['w1'])

    def getBiases(self):
        # 得到编码器的偏重值
        return self.sess.run(self.weights['b1'])
降噪自编码器
emptyclass AdditiveGaussianNoiseAutoencoder(object):
    # 在初始的数据中加入高斯噪声。在实现降噪自编码器的时候,
    # 只是在输入加进去的时候,在输入上加上高斯噪声就行
    # 其他的部分和基本自编码器一样
    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
        # n_input,n_hidden都是输入和隐藏层的维度
        self.transfer = transfer_function
        self.scale = tf.placeholder(tf.float32)
        self.training_scale = scale
        # scale 就是一个标量
        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        # none不给定具体的值,它由输入的数目来决定
        self.hidden = self.transfer(tf.add(tf.matmul(self.x + scale * tf.random_normal((n_input,)),
                self.weights['w1']),
                self.weights['b1']))
        # 在输入的时候,在输入的数据上加上一些高斯噪声
        # tf.random_normal((n_input,)) 默认
        # 给的是一个均值为0,标准差是1的正态分布的随机数

        self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])

        # cost
        self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.sub(self.reconstruction, self.x), 2.0))
        self.optimizer = optimizer.minimize(self.cost)

        init = tf.initialize_all_variables()
        self.sess = tf.Session()
        self.sess.run(init)
        
        
        
        
class MaskingNoiseAutoencoder(object):
    # 将有些数据直接忽略掉,即直接将一部分数据直接赋予0
    def __init__(self, n_input, n_hidden, transfer_function = tf.nn.softplus, optimizer = tf.train.AdamOptimizer(),
                 dropout_probability = 0.95):
        self.n_input = n_input
        self.n_hidden = n_hidden
        self.transfer = transfer_function
        self.dropout_probability = dropout_probability
        self.keep_prob = tf.placeholder(tf.float32)

        network_weights = self._initialize_weights()
        self.weights = network_weights

        # model
        # 直接在输入数据上使用dropout来实现它,这样就实现了masking noise
        self.x = tf.placeholder(tf.float32, [None, self.n_input])
        self.hidden = self.transfer(tf.add(tf.matmul(tf.nn.dropout(self.x, self.keep_prob), self.weights['w1']),
                                           self.weights['b1']))
        self.reconstruction = tf.add(tf.matmul(self.hidden, self.weights['w2']), self.weights['b2'])

        # cost
        self.cost = 0.5 * tf.reduce_sum(tf.pow(tf.sub(self.reconstruction, self.x), 2.0))
        self.optimizer = optimizer.minimize(self.cost)

        init = tf.initialize_all_variables()
        self.sess = tf.Session()
        self.sess.run(init)









 

















你可能感兴趣的:(人工智能和深度学习)