深度学习算法实践14---去噪自动编码机（dA）的Theano实现

在明白了去噪自动编码机（dA）的理论之后，在本篇博文中，我们将讨论用Theano来实现一个去噪自动编码机。

通过上篇博文的讨论，我们知道去噪自动编码机（dA）工作主要有四步组成：第一步是向原始输入信号中加入随机噪音（使原始信号在某些维度上值为零）；第二步是将加入噪音的信号输入网络，经过编码器部分，在中间层生成输入信号的压缩信号；第三步是经过解码器层，在输出层得到输出信号；第四步将输出信号与原始输入信号相比较，求出误差，然后根据随机梯度下降算法，更新网络的连接权值。我们通过定义去噪自动编码机（DenosingAutoencoder）类，来实现这些功能，代码如下所示：

[python]  view plain  copy

 

1. from __future__ import print_function  
2.   
3. import os  
4. import sys  
5. import timeit  
6.   
7. import numpy  
8.   
9. import theano  
10. import theano.tensor as T  
11. from theano.tensor.shared_randomstreams import RandomStreams  
12.   
13.   
14. class DenosingAutoencoder(object):  
15.     def __init__(  
16.         self,  
17.         numpy_rng,  
18.         theano_rng=None,  
19.         input=None,  
20.         n_visible=784,  
21.         n_hidden=500,  
22.         W=None,  
23.         bhid=None,  
24.         bvis=None  
25.     ):  
26.         self.n_visible = n_visible  
27.         self.n_hidden = n_hidden  
28.         if not theano_rng:  
29.             theano_rng = RandomStreams(numpy_rng.randint(2 ** 30))  
30.         if not W:  
31.             initial_W = numpy.asarray(  
32.                 numpy_rng.uniform(  
33.                     low=-4 * numpy.sqrt(6. / (n_hidden + n_visible)),  
34.                     high=4 * numpy.sqrt(6. / (n_hidden + n_visible)),  
35.                     size=(n_visible, n_hidden)  
36.                 ),  
37.                 dtype=theano.config.floatX  
38.             )  
39.             W = theano.shared(value=initial_W, name='W', borrow=True)  
40.   
41.         if not bvis:  
42.             bvis = theano.shared(  
43.                 value=numpy.zeros(  
44.                     n_visible,  
45.                     dtype=theano.config.floatX  
46.                 ),  
47.                 borrow=True  
48.             )  
49.   
50.         if not bhid:  
51.             bhid = theano.shared(  
52.                 value=numpy.zeros(  
53.                     n_hidden,  
54.                     dtype=theano.config.floatX  
55.                 ),  
56.                 name='b',  
57.                 borrow=True  
58.             )  
59.         self.W = W  
60.         self.b = bhid  
61.         self.b_prime = bvis  
62.         self.W_prime = self.W.T  
63.         self.theano_rng = theano_rng  
64.         if input is None:  
65.             self.x = T.dmatrix(name='input')  
66.         else:  
67.             self.x = input  
68.         self.params = [self.W, self.b, self.b_prime]  
69.   
70.     def get_corrupted_input(self, input, corruption_level):  
71.         return self.theano_rng.binomial(size=input.shape, n=1,  
72.                                         p=1 - corruption_level,  
73.                                         dtype=theano.config.floatX) * input  
74.   
75.     def get_hidden_values(self, input):  
76.         return T.nnet.sigmoid(T.dot(input, self.W) + self.b)  
77.   
78.     def get_reconstructed_input(self, hidden):  
79.         return T.nnet.sigmoid(T.dot(hidden, self.W_prime) + self.b_prime)  
80.   
81.     def get_cost_updates(self, corruption_level, learning_rate):  
82.         tilde_x = self.get_corrupted_input(self.x, corruption_level)  
83.         y = self.get_hidden_values(tilde_x)  
84.         z = self.get_reconstructed_input(y)  
85.         L = - T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1)  
86.         cost = T.mean(L)  
87.         gparams = T.grad(cost, self.params)  
88.         updates = [  
89.             (param, param - learning_rate * gparam)  
90.             for param, gparam in zip(self.params, gparams)  
91.         ]  
92.   
93.         return (cost, updates)  

在上面代码中，首先是去噪自动编码机的构造函数，在其中对网络参数进行初始化，各参数的含义如下所示：

numpy_rng：随机数生成引擎，用于生成随机的连接权值

input：网络的输入信号，如果是独立的去噪自动编码机，该值为空，如果是堆叠去噪自动编码机的话，则其为前一层去噪自动编码机的输出层

n_visible：输出层神经元数目

n_hidden：中间层神经元数目

W：层间神经元的连接权值矩阵

bhid：中间层神经元Bias值向量

bvis：输出层神经元Bias值向量

需要注意的是，我们所定义的去噪自动编码机（dA）采用中间隐藏层到输出层的连接权值向量是输入层到中间隐藏层连接权值向量的转置，即：。另外，我们信号重建过程中的交叉熵来定义我们的误差：

式1

在定义好了去噪自动编码机（dA）之后，我们来定义DAMnistEngine，用来装入MNIST数据，并对其进行训练，代码如下所示：

[python]  view plain  copy

 

1. from __future__ import print_function  
2.   
3. import os  
4. import sys  
5. import timeit  
6.   
7. import numpy  
8.   
9. import theano  
10. import theano.tensor as T  
11. from theano.tensor.shared_randomstreams import RandomStreams  
12.   
13. from mnist_loader import MnistLoader  
14. from denosing_autoencoder import DenosingAutoencoder  
15. from dlt_utils import tile_raster_images  
16.   
17. try:  
18.     import PIL.Image as Image  
19. except ImportError:  
20.     import Image  
21.   
22. class DAMnistEngine(object):  
23.     def train(self, learning_rate=0.1, training_epochs=15,  
24.                 dataset='mnist.pkl.gz',  
25.                 batch_size=20, output_folder='dA_plots'):  
26.         loader = MnistLoader()  
27.         datasets = loader.load_data(dataset)  
28.         train_set_x, train_set_y = datasets[0]  
29.         n_train_batches = train_set_x.get_value(borrow=True).shape[0] // batch_size  
30.         index = T.lscalar()      
31.         x = T.matrix('x')    
32.         if not os.path.isdir(output_folder):  
33.             os.makedirs(output_folder)  
34.         os.chdir(output_folder)  
35.         self.train_da(x, learning_rate, train_set_x, index, batch_size, \  
36.             training_epochs, n_train_batches, 'filters_corruption_0.png', 0.0)  
37.         self.train_da(x, learning_rate, train_set_x, index, batch_size, \  
38.             training_epochs, n_train_batches, 'filters_corruption_30.png', 0.3)  
39.         os.chdir('../')  
40.   
41.     def train_da(self, x, learning_rate, train_set_x, index, batch_size,   
42.                         training_epochs, n_train_batches,   
43.                         img_file,   
44.                         corruption_level=0.0):  
45.         rng = numpy.random.RandomState(123)  
46.         theano_rng = RandomStreams(rng.randint(2 ** 30))  
47.         da = DenosingAutoencoder(  
48.             numpy_rng=rng,  
49.             theano_rng=theano_rng,  
50.             input=x,  
51.             n_visible=28 * 28,  
52.             n_hidden=500  
53.         )  
54.         cost, updates = da.get_cost_updates(  
55.             corruption_level=corruption_level,  
56.             learning_rate=learning_rate  
57.         )  
58.         train_da = theano.function(  
59.             [index],  
60.             cost,  
61.             updates=updates,  
62.             givens={  
63.                 x: train_set_x[index * batch_size: (index + 1) * batch_size]  
64.             }  
65.         )  
66.         start_time = timeit.default_timer()  
67.         for epoch in range(training_epochs):  
68.             c = []  
69.             for batch_index in range(n_train_batches):  
70.                 c.append(train_da(batch_index))  
71.             print('Training epoch %d, cost ' % epoch, numpy.mean(c))  
72.         end_time = timeit.default_timer()  
73.         training_time = (end_time - start_time)  
74.         print(('The no corruption code for file ' +  
75.                os.path.split(__file__)[1] +  
76.                ' ran for %.2fm' % ((training_time) / 60.)), file=sys.stderr)  
77.         image = Image.fromarray(  
78.             tile_raster_images(X=da.W.get_value(borrow=True).T,  
79.                                img_shape=(28, 28), tile_shape=(10, 10),  
80.                                tile_spacing=(1, 1)))  
81.         image.save(img_file)  
82.   
83.     def run():  
84.         print('run Denosing Autoencoder...')  

在上面的代码中，我们分别用原始信号和有30%噪音的信号作为输入信号，训练我们的去噪自动编码机（dA）网络，并将训练完成后的权值，以图像的形式打印出来，大家可以看到两种方式训练结束后的权值差异。

我们可以通过如下代码，运行并训练我们的去噪自动编码机（dA）：

[python]  view plain  copy

 

1. from d_a_mnist_engine import DAMnistEngine  
2.   
3. if __name__ == '__main__':  
4.     engine = DAMnistEngine()  
5.     engine.train()  

由于去噪自动编码机（dA）很少单独使用，所以我们就不再讨论单独运行的问题了，我们在堆叠去噪自动编码机（dA）中再讨论这一问题。

有了单层的去噪自动编码机（dA）之后，我们将在下一篇博文中讨论堆叠自动编码机（dA）的原理、实现和应用。