Commit 73d63de

让人惊讶地，在[Bengio07](http://deeplearning.net/tutorial/references.html#bengio07)的实验指出，在实践中，当通过随机梯度下降训练时，有比输入更多的隐藏单元（称为超完备）的非线性的自动编码机可以产生有效的表达。（这里，有效指的是编码作为网络的输入获得了更低的分类误差）。

一个简单的解释是，使用early-stopping的随机梯度下降是与参数的L2正则化相似的。为了去实现对连续性输入有更好的重建，包含非线性隐藏单元的单隐藏层的自动编码机需要非常小的权值在第一（编码）层，以使得将非线性隐藏单元进入他们的线性区域（参考sigmoid函数），然后在第二（解码）层有更大的权值。对于二进制输入，非常大的权值也需要彻底的最小化重构误差。因为隐性的或者显性的正则化将使得获得大权值的解决方案变得困难，这个最优化算法发现在训练样本中表现好的编码。这意味着，表达是利用训练集的统计规律来实现的，而不仅仅是复制输入。

这里有其他方法，使得一个有比输入有更多隐藏单元的自动编码机，去避免只学习它本身，而是在输入的隐藏表达中捕捉到有用的东西。一个是添加稀疏性（迫使许多隐单元是0或者接近0）。稀疏性已经被很成功的发挥了[Ranzato07](http://deeplearning.net/tutorial/references.html#ranzato07)[Lee08](http://deeplearning.net/tutorial/references.html#lee08)。另一个是，在输入到重建过程中，增加从输入到重建的转换中的随机性。这个技术在受限玻尔兹曼机中被使用（Restricted Boltzmann Machines，在后面的章节中讨论），还有降噪自动编码机，在后面讨论。

###降噪自动编码机

降噪自动编码机的思想是很简单饿。为了迫使隐藏层去发现更加鲁棒性的特征，避免它只是去简单的学习定义，我们训练自动编码机去重建被破坏的输入版本的数据。

这个降噪自动编码机是自动编码机的随机版本。直观上讲，一个降噪自动编码机做2件事情：尝试对输入进行编码（保护输入信息），然后尝试去消除输入中的随机差错产生的影响。后者可以通过捕捉输入间的统计相关性来实现。降噪自动编码机可以从不到的角度来理解（流行学习角度，随机操作角度，自下而上的信息论角度，自上而下的生成模型角度），所有的这些在[Vincent08](http://deeplearning.net/tutorial/references.html#vincent08)中被解释。在[Bengio09](http://deeplearning.net/tutorial/references.html#bengio09)的第7.2节有自动编码机的综述。

在[Vincent08](http://deeplearning.net/tutorial/references.html#vincent08)中，随机差错进程随机的设定部分（也可以是一半）输入为0。因此降噪自动编码机尝试去从未被污染的值中去预测被污染的（丢失）的值，通过随机的选择丢失模式下的仔鸡。注意如何能预测从剩下的变量的任意子集是一个充分条件，去完全捕获一组变量之间的联合分布（这是Gibbs采样工作）。

从自动编码机的类转换为降噪自动编码机，我们需要去增加一个随机误差步骤去应用到输入中。这个输入可以通过许多方法来污染，但在这个教程中，我们将支持以输入的随机性来腐化原始数据，使它趋向于0。代码如下：

from theano.tensor.shared_randomstreams import RandomStreams

def get_corrupted_input(self, input, corruption_level):

""" This function keeps ``1-corruption_level`` entries of the inputs the same

return self.theano_rng.binomial(size=input.shape, n=1, p=1 - corruption_level) * input

在层叠自动编码机类([层叠自动编码机](http://deeplearning.net/tutorial/SdA.html#stacked-autoencoders))中，`dA`类中的权值不得不和相应的sigmoid层共享。因为这个原因，dA的构建也将Theano变量指向了共享参数。假如这些参数被设置为`None`，新的参数会被构建。

最后的降噪自动编码机类就变成了这样：

class dA(object):

"""Denoising Auto-Encoder class (dA)

def __init__(self, numpy_rng, theano_rng=None, input=None, n_visible=784, n_hidden=500,

W=None, bhid=None, bvis=None):

"""

self.n_visible = n_visible

self.n_hidden = n_hidden

# create a Theano random generator that gives symbolic random values

if not theano_rng :

theano_rng = RandomStreams(rng.randint(2 ** 30))

# note : W' was written as `W_prime` and b' as `b_prime`

if not W:

# W is initialized with `initial_W` which is uniformely sampled

# from -4.*sqrt(6./(n_visible+n_hidden)) and 4.*sqrt(6./(n_hidden+n_visible))

# the output of uniform if converted using asarray to dtype

# theano.config.floatX so that the code is runable on GPU

initial_W = numpy.asarray(numpy_rng.uniform(

low=-4 * numpy.sqrt(6. / (n_hidden + n_visible)),

high=4 * numpy.sqrt(6. / (n_hidden + n_visible)),

size=(n_visible, n_hidden)), dtype=theano.config.floatX)

W = theano.shared(value=initial_W, name='W')

if not bvis:

bvis = theano.shared(value = numpy.zeros(n_visible,

dtype=theano.config.floatX), name='bvis')

if not bhid:

bhid = theano.shared(value=numpy.zeros(n_hidden,

dtype=theano.config.floatX), name='bhid')

self.W = W

# b corresponds to the bias of the hidden

self.b = bhid

# b_prime corresponds to the bias of the visible

self.b_prime = bvis

# tied weights, therefore W_prime is W transpose

self.W_prime = self.W.T

self.theano_rng = theano_rng

# if no input is given, generate a variable representing the input

if input == None:

# we use a matrix because we expect a minibatch of several examples,

# each example being a row

self.x = T.dmatrix(name='input')

else:

self.x = input

self.params = [self.W, self.b, self.b_prime]

def get_corrupted_input(self, input, corruption_level):

""" This function keeps ``1-corruption_level`` entries of the inputs the same

return self.theano_rng.binomial(size=input.shape, n=1, p=1 - corruption_level) * input

def get_hidden_values(self, input):

""" Computes the values of the hidden layer """

return T.nnet.sigmoid(T.dot(input, self.W) + self.b)

def get_reconstructed_input(self, hidden ):

""" Computes the reconstructed input given the values of the hidden layer """

return T.nnet.sigmoid(T.dot(hidden, self.W_prime) + self.b_prime)

def get_cost_updates(self, corruption_level, learning_rate):

""" This function computes the cost and the updates for one trainng

tilde_x = self.get_corrupted_input(self.x, corruption_level)

y = self.get_hidden_values( tilde_x)

z = self.get_reconstructed_input(y)

# note : we sum over the size of a datapoint; if we are using minibatches,

# L will be a vector, with one entry per example in minibatch

L = -T.sum(self.x * T.log(z) + (1 - self.x) * T.log(1 - z), axis=1 )

# note : L is now a vector, where each element is the cross-entropy cost

# of the reconstruction of the corresponding example of the

# minibatch. We need to compute the average of all these to get

# the cost of the minibatch

cost = T.mean(L)

# compute the gradients of the cost of the `dA` with respect

# to its parameters

gparams = T.grad(cost, self.params)

# generate the list of updates

updates = []

for param, gparam in zip(self.params, gparams):

updates.append((param, param - learning_rate * gparam))

return (cost, updates)

###将它组合起来

现在去构建一个`dA`类和训练它变得很简单了。

index = T.lscalar() # index to a [mini]batch

x = T.matrix('x') # the data is presented as rasterized images

rng = numpy.random.RandomState(123)

theano_rng = RandomStreams(rng.randint(2 ** 30))

da = dA(numpy_rng=rng, theano_rng=theano_rng, input=x,

n_visible=28 * 28, n_hidden=500)

cost, updates = da.get_cost_updates(corruption_level=0.2,

learning_rate=learning_rate)

train_da = theano.function([index], cost, updates=updates,

givens = {x: train_set_x[index * batch_size: (index + 1) * batch_size]})

start_time = time.clock()

for epoch in xrange(training_epochs):

# go through trainng set

c = []

for batch_index in xrange(n_train_batches):

c.append(train_da(batch_index))

print 'Training epoch %d, cost ' % epoch, numpy.mean(c)

end_time = time.clock

training_time = (end_time - start_time)

print ('Training took %f minutes' % (pretraining_time / 60.))

为了了解网络学习了什么东西，我们将会描述出滤波器（通过权值矩阵来定义）。记住，事实上它没有提供完整的情况，因为我们忽略了偏置，并且画出的权值被乘以了常数（权值被转换到了0-1之间）。

去画出我们的滤波器，我们需要`title_raster_images`(看[Plotting Samples and Filters](http://deeplearning.net/tutorial/utilities.html#how-to-plot))，所以我们强烈建议读者去了解它。当然，也在PIL(python image library)的帮助下，下面行的代码将把滤波器保存为图像：

image = Image.fromarray(tile_raster_images(X=da.W.get_value(borrow=True).T,

img_shape=(28, 28), tile_shape=(10, 10),

tile_spacing=(1, 1)))

image.save('filters_corruption_30.png')

###运行这个代码

当我们不使用任何噪声的时候，获得的滤波器如下：


有30%噪声的时候，滤波器如下：