DeepLearning tutorial（3）MLP多层感知机原理简介+代码详解

@author：wepon

@blog：http://blog.csdn.net/u012162613/article/details/43221829

本文介绍多层感知机算法，特别是详细解读其代码实现，基于Python theano，代码来自：Multilayer Perceptron，如果你想详细了解多层感知机算法，可以参考：UFLDL教程，或者参考本文第一部分的算法简介。

经详细注释的代码：放在我的github地址上，可下载。

一、多层感知机（MLP）原理简介

多层感知机（MLP，Multilayer Perceptron）也叫人工神经网络（ANN，Artificial Neural Network），除了输入输出层，它中间可以有多个隐层，最简单的MLP只含一个隐层，即三层的结构，如下图：

从上图可以看到，多层感知机层与层之间是全连接的（全连接的意思就是：上一层的任何一个神经元与下一层的所有神经元都有连接）。多层感知机最底层是输入层，中间是隐藏层，最后是输出层。

输入层没什么好说，你输入什么就是什么，比如输入是一个n维向量，就有n个神经元。

隐藏层的神经元怎么得来？首先它与输入层是全连接的，假设输入层用向量X表示，则隐藏层的输出就是

f(W1X+b1)，W1是权重（也叫连接系数），b1是偏置，函数f 可以是常用的sigmoid函数或者tanh函数：

最后就是输出层，输出层与隐藏层是什么关系？其实隐藏层到输出层可以看成是一个多类别的逻辑回归，也即softmax回归，所以输出层的输出就是softmax(W2X1+b2)，X1表示隐藏层的输出f(W1X+b1)。

MLP整个模型就是这样子的，上面说的这个三层的MLP用公式总结起来就是，函数G是softmax

因此，MLP所有的参数就是各个层之间的连接权重以及偏置，包括W1、b1、W2、b2。对于一个具体的问题，怎么确定这些参数？求解最佳的参数是一个最优化问题，解决最优化问题，最简单的就是梯度下降法了（SGD）：首先随机初始化所有参数，然后迭代地训练，不断地计算梯度和更新参数，直到满足某个条件为止（比如误差足够小、迭代次数足够多时）。这个过程涉及到代价函数、规则化（Regularization）、学习速率（learning rate）、梯度计算等，本文不详细讨论，读者可以参考本文顶部给出的两个链接。

了解了MLP的基本模型，下面进入代码实现部分。

二、多层感知机（MLP）代码详细解读（基于python+theano）

再次说明，代码来自：Multilayer Perceptron，本文只是做一个详细解读，如有错误，请不吝指出。

这个代码实现的是一个三层的感知机，但是理解了代码之后，实现n层感知机都不是问题，所以只需理解好这个三层的MLP模型即可。概括地说，MLP的输入层X其实就是我们的训练数据，所以输入层不用实现，剩下的就是“输入层到隐含层”，“隐含层到输出层”这两部分。上面介绍原理时已经说到了，“输入层到隐含层”就是一个全连接的层，在下面的代码中我们把这一部分定义为HiddenLayer。“隐含层到输出层”就是一个分类器softmax回归（也有人叫逻辑回归），在下面的代码中我们把这一部分定义为LogisticRegression。

代码详解开始：

（1）导入必要的python模块

主要是numpy、theano，以及python自带的os、sys、time模块，这些模块的使用在下面的程序中会看到。

[python] view plain copy

1. import os
2. import sys
3. import time
4. import numpy
5. import theano
6. import theano.tensor as T

（2）定义MLP模型（HiddenLayer+LogisticRegression）

这一部分定义MLP的基本“构件”，即上文一直在提的HiddenLayer和LogisticRegression

• HiddenLayer

隐含层我们需要定义连接系数W、偏置b，输入、输出，具体的代码以及解读如下：

[python] view plain copy

1. class HiddenLayer(object):
2. def __init__(self, rng, input, n_in, n_out, W=None, b=None,
3. activation=T.tanh):
4. """
5. 注释：
6. 这是定义隐藏层的类，首先明确：隐藏层的输入即input，输出即隐藏层的神经元个数。输入层与隐藏层是全连接的。
7. 假设输入是n_in维的向量（也可以说时n_in个神经元），隐藏层有n_out个神经元，则因为是全连接，
8. 一共有n_in*n_out个权重，故W大小时(n_in,n_out),n_in行n_out列，每一列对应隐藏层的每一个神经元的连接权重。
9. b是偏置，隐藏层有n_out个神经元，故b时n_out维向量。
10. rng即随机数生成器，numpy.random.RandomState，用于初始化W。
11. input训练模型所用到的所有输入，并不是MLP的输入层，MLP的输入层的神经元个数时n_in，而这里的参数input大小是（n_example,n_in）,每一行一个样本，即每一行作为MLP的输入层。
12. activation:激活函数,这里定义为函数tanh
13. """
14. self.input = input   #类HiddenLayer的input即所传递进来的input
15. """
16. 注释：
17. 代码要兼容GPU，则W、b必须使用 dtype=theano.config.floatX,并且定义为theano.shared
18. 另外，W的初始化有个规则：如果使用tanh函数，则在-sqrt(6./(n_in+n_hidden))到sqrt(6./(n_in+n_hidden))之间均匀
19. 抽取数值来初始化W，若时sigmoid函数，则以上再乘4倍。
20. """
21. #如果W未初始化，则根据上述方法初始化。
22. #加入这个判断的原因是：有时候我们可以用训练好的参数来初始化W，见我的上一篇文章。
23. if W is None:
24. W_values = numpy.asarray(  #asarray是将数据变成矩阵（这里数据变成theano的floatX格式）
25. rng.uniform(  #将随机数标准化（low - high）
26. low=-numpy.sqrt(6. / (n_in + n_out)),
27. high=numpy.sqrt(6. / (n_in + n_out)),
28. size=(n_in, n_out)
29. ),
30. dtype=theano.config.floatX  #将数据修改成theano的floatX格式
31. )
32. if activation == theano.tensor.nnet.sigmoid:
33. W_values *= 4
34. W = theano.shared(value=W_values, name=‘W‘, borrow=True) #shared就是把参数变成theano的全局变量
35. if b is None:
36. b_values = numpy.zeros((n_out,), dtype=theano.config.floatX)
37. b = theano.shared(value=b_values, name=‘b‘, borrow=True)
38. #用上面定义的W、b来初始化类HiddenLayer的W、b
39. self.W = W
40. self.b = b
41. #隐含层的输出
42. lin_output = T.dot(input, self.W) + self.b
43. self.output = (
44. lin_output if activation is None
45. else activation(lin_output)
46. )
47. #隐含层的参数
48. self.params = [self.W, self.b]

• LogisticRegression

逻辑回归（softmax回归），代码详解如下。

（如果你想详细了解softmax回归，可以参考： DeepLearning tutorial（1）Softmax回归原理简介+代码详解）

[python] view plain copy

1. """
2. 定义分类层，Softmax回归
3. 在deeplearning tutorial中，直接将LogisticRegression视为Softmax，
4. 而我们所认识的二类别的逻辑回归就是当n_out=2时的LogisticRegression
5. """
6. #参数说明：
7. #input，大小就是(n_example,n_in)，其中n_example是一个batch的大小，
8. #因为我们训练时用的是Minibatch SGD，因此input这样定义
9. #n_in,即上一层(隐含层)的输出
10. #n_out,输出的类别数
11. class LogisticRegression(object):
12. def __init__(self, input, n_in, n_out):
13. #W大小是n_in行n_out列，b为n_out维向量。即：每个输出对应W的一列以及b的一个元素。
14. self.W = theano.shared(
15. value=numpy.zeros(
16. (n_in, n_out),
17. dtype=theano.config.floatX
18. ),
19. name=‘W‘,
20. borrow=True
21. )
22. self.b = theano.shared(
23. value=numpy.zeros(
24. (n_out,),
25. dtype=theano.config.floatX
26. ),
27. name=‘b‘,
28. borrow=True
29. )
30. #input是(n_example,n_in)，W是（n_in,n_out）,点乘得到(n_example,n_out)，加上偏置b，
31. #再作为T.nnet.softmax的输入，得到p_y_given_x
32. #故p_y_given_x每一行代表每一个样本被估计为各类别的概率
33. #PS：b是n_out维向量，与(n_example,n_out)矩阵相加，内部其实是先复制n_example个b，
34. #然后(n_example,n_out)矩阵的每一行都加b
35. self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
36. #argmax返回最大值下标，因为本例数据集是MNIST，下标刚好就是类别。axis=1表示按行操作。
37. self.y_pred = T.argmax(self.p_y_given_x, axis=1)
38. #params，LogisticRegression的参数
39. self.params = [self.W, self.b]

ok！这两个基本“构件”做好了，现在我们可以将它们“组装”在一起。

我们要三层的MLP，则只需要HiddenLayer+LogisticRegression，

如果要四层的MLP，则为HiddenLayer+HiddenLayer+LogisticRegression........以此类推。

下面是三层的MLP：

[python] view plain copy

1. #3层的MLP
2. class MLP(object):
3. def __init__(self, rng, input, n_in, n_hidden, n_out):
4. self.hiddenLayer = HiddenLayer(
5. rng=rng,
6. input=input,
7. n_in=n_in,
8. n_out=n_hidden,
9. activation=T.tanh
10. )
11. #将隐含层hiddenLayer的输出作为分类层logRegressionLayer的输入，这样就把它们连接了
12. self.logRegressionLayer = LogisticRegression(
13. input=self.hiddenLayer.output,
14. n_in=n_hidden,
15. n_out=n_out
16. )
17. #以上已经定义好MLP的基本结构，下面是MLP模型的其他参数或者函数
18. #规则化项：常见的L1、L2_sqr
19. self.L1 = (
20. abs(self.hiddenLayer.W).sum()
21. + abs(self.logRegressionLayer.W).sum()
22. )
23. self.L2_sqr = (
24. (self.hiddenLayer.W ** 2).sum()
25. + (self.logRegressionLayer.W ** 2).sum()
26. )
27. #损失函数Nll（也叫代价函数）
28. self.negative_log_likelihood = (
29. self.logRegressionLayer.negative_log_likelihood
30. )
31. #误差
32. self.errors = self.logRegressionLayer.errors
33. #MLP的参数
34. self.params = self.hiddenLayer.params + self.logRegressionLayer.params
35. # end-snippet-3

MLP类里面除了隐含层和分类层，还定义了损失函数、规则化项，这是在求解优化算法时用到的。

（3）将MLP应用于MNIST（手写数字识别）

上面定义好了一个三层的MLP，接下来使用它在MNIST数据集上分类，MNIST是一个手写数字0～9的数据集。

首先定义加载数据 mnist.pkl.gz 的函数load_data()：

[python] view plain copy

1. """
2. 加载MNIST数据集
3. """
4. def load_data(dataset):
5. # dataset是数据集的路径，程序首先检测该路径下有没有MNIST数据集，没有的话就下载MNIST数据集
6. #这一部分就不解释了，与softmax回归算法无关。
7. data_dir, data_file = os.path.split(dataset)
8. if data_dir == "" and not os.path.isfile(dataset):
9. # Check if dataset is in the data directory.
10. new_path = os.path.join(
11. os.path.split(__file__)[0],
12. "..",
13. "data",
14. dataset
15. )
16. if os.path.isfile(new_path) or data_file == ‘mnist.pkl.gz‘:
17. dataset = new_path
18. if (not os.path.isfile(dataset)) and data_file == ‘mnist.pkl.gz‘:
19. import urllib
20. origin = (
21. ‘http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz‘
22. )
23. print ‘Downloading data from %s‘ % origin
24. urllib.urlretrieve(origin, dataset)
25. print ‘... loading data‘
26. #以上是检测并下载数据集mnist.pkl.gz，不是本文重点。下面才是load_data的开始
27. #从"mnist.pkl.gz"里加载train_set, valid_set, test_set，它们都是包括label的
28. #主要用到python里的gzip.open()函数,以及 cPickle.load()。
29. #‘rb’表示以二进制可读的方式打开文件
30. f = gzip.open(dataset, ‘rb‘)
31. train_set, valid_set, test_set = cPickle.load(f)
32. f.close()
33. #将数据设置成shared variables，主要时为了GPU加速，只有shared variables才能存到GPU memory中
34. #GPU里数据类型只能是float。而data_y是类别，所以最后又转换为int返回
35. def shared_dataset(data_xy, borrow=True):
36. data_x, data_y = data_xy
37. shared_x = theano.shared(numpy.asarray(data_x,
38. dtype=theano.config.floatX),
39. borrow=borrow)
40. shared_y = theano.shared(numpy.asarray(data_y,
41. dtype=theano.config.floatX),
42. borrow=borrow)
43. return shared_x, T.cast(shared_y, ‘int32‘)
44. test_set_x, test_set_y = shared_dataset(test_set)
45. valid_set_x, valid_set_y = shared_dataset(valid_set)
46. train_set_x, train_set_y = shared_dataset(train_set)
47. rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y),
48. (test_set_x, test_set_y)]
49. return rval

加载了数据，可以开始训练这个模型了，以下就是主体函数test_mlp()，将MLP用在MNIST上：

[python] view plain copy

1. #test_mlp是一个应用实例，用梯度下降来优化MLP，针对MNIST数据集
2. def test_mlp(learning_rate=0.01, L1_reg=0.00, L2_reg=0.0001, n_epochs=10,
3. dataset=‘mnist.pkl.gz‘, batch_size=20, n_hidden=500):
4. """
5. 注释：
6. learning_rate学习速率，梯度前的系数。
7. L1_reg、L2_reg：正则化项前的系数，权衡正则化项与Nll项的比重
8. 代价函数=Nll+L1_reg*L1或者L2_reg*L2_sqr
9. n_epochs：迭代的最大次数（即训练步数），用于结束优化过程
10. dataset：训练数据的路径
11. n_hidden:隐藏层神经元个数
12. batch_size=20，即每训练完20个样本才计算梯度并更新参数
13. """
14. #加载数据集，并分为训练集、验证集、测试集。
15. datasets = load_data(dataset)
16. train_set_x, train_set_y = datasets[0]
17. valid_set_x, valid_set_y = datasets[1]
18. test_set_x, test_set_y = datasets[2]
19. #shape[0]获得行数，一行代表一个样本，故获取的是样本数，除以batch_size可以得到有多少个batch
20. n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size
21. n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size
22. n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size
23. ######################
24. # BUILD ACTUAL MODEL #
25. ######################
26. print ‘... building the model‘
27. #index表示batch的下标，标量
28. #x表示数据集
29. #y表示类别，一维向量
30. index = T.lscalar()
31. x = T.matrix(‘x‘)
32. y = T.ivector(‘y‘)
33. rng = numpy.random.RandomState(1234)
34. #生成一个MLP，命名为classifier
35. classifier = MLP(
36. rng=rng,
37. input=x,
38. n_in=28 * 28,
39. n_hidden=n_hidden,
40. n_out=10
41. )
42. #代价函数，有规则化项
43. #用y来初始化，而其实还有一个隐含的参数x在classifier中
44. cost = (
45. classifier.negative_log_likelihood(y)
46. + L1_reg * classifier.L1
47. + L2_reg * classifier.L2_sqr
48. )
49. #这里必须说明一下theano的function函数，givens是字典，其中的x、y是key，冒号后面是它们的value。
50. #在function被调用时，x、y将被具体地替换为它们的value，而value里的参数index就是inputs=[index]这里给出。
51. #下面举个例子：
52. #比如test_model(1)，首先根据index=1具体化x为test_set_x[1 * batch_size: (1 + 1) * batch_size]，
53. #具体化y为test_set_y[1 * batch_size: (1 + 1) * batch_size]。然后函数计算outputs=classifier.errors(y)，
54. #这里面有参数y和隐含的x，所以就将givens里面具体化的x、y传递进去。
55. test_model = theano.function(
56. inputs=[index],
57. outputs=classifier.errors(y),
58. givens={
59. x: test_set_x[index * batch_size:(index + 1) * batch_size],
60. y: test_set_y[index * batch_size:(index + 1) * batch_size]
61. }
62. )
63. validate_model = theano.function(
64. inputs=[index],
65. outputs=classifier.errors(y),
66. givens={
67. x: valid_set_x[index * batch_size:(index + 1) * batch_size],
68. y: valid_set_y[index * batch_size:(index + 1) * batch_size]
69. }
70. )
71. #cost函数对各个参数的偏导数值，即梯度，存于gparams
72. gparams = [T.grad(cost, param) for param in classifier.params]
73. #参数更新规则
74. #updates[(),(),()....],每个括号里面都是(param, param - learning_rate * gparam)，即每个参数以及它的更新公式
75. updates = [
76. (param, param - learning_rate * gparam)
77. for param, gparam in zip(classifier.params, gparams)
78. ]
79. train_model = theano.function(
80. inputs=[index],
81. outputs=cost,
82. updates=updates,
83. givens={
84. x: train_set_x[index * batch_size: (index + 1) * batch_size],
85. y: train_set_y[index * batch_size: (index + 1) * batch_size]
86. }
87. )
88. ###############
89. # 开始训练模型 #
90. ###############
91. print ‘... training‘
92. patience = 10000
93. patience_increase = 2
94. #提高的阈值，在验证误差减小到之前的0.995倍时，会更新best_validation_loss
95. improvement_threshold = 0.995
96. #这样设置validation_frequency可以保证每一次epoch都会在验证集上测试。
97. validation_frequency = min(n_train_batches, patience / 2)
98. best_validation_loss = numpy.inf
99. best_iter = 0
100. test_score = 0.
101. start_time = time.clock()
102. #epoch即训练步数，每个epoch都会遍历所有训练数据
103. epoch = 0
104. done_looping = False
105. #下面就是训练过程了，while循环控制的时步数epoch，一个epoch会遍历所有的batch，即所有的图片。
106. #for循环是遍历一个个batch，一次一个batch地训练。for循环体里会用train_model(minibatch_index)去训练模型，
107. #train_model里面的updatas会更新各个参数。
108. #for循环里面会累加训练过的batch数iter，当iter是validation_frequency倍数时则会在验证集上测试，
109. #如果验证集的损失this_validation_loss小于之前最佳的损失best_validation_loss，
110. #则更新best_validation_loss和best_iter，同时在testset上测试。
111. #如果验证集的损失this_validation_loss小于best_validation_loss*improvement_threshold时则更新patience。
112. #当达到最大步数n_epoch时，或者patience<iter时，结束训练
113. while (epoch < n_epochs) and (not done_looping):
114. epoch = epoch + 1
115. for minibatch_index in xrange(n_train_batches):#训练时一个batch一个batch进行的
116. minibatch_avg_cost = train_model(minibatch_index)
117. # 已训练过的minibatch数，即迭代次数iter
118. iter = (epoch - 1) * n_train_batches + minibatch_index
119. #训练过的minibatch数是validation_frequency倍数，则进行交叉验证
120. if (iter + 1) % validation_frequency == 0:
121. # compute zero-one loss on validation set
122. validation_losses = [validate_model(i) for i
123. in xrange(n_valid_batches)]
124. this_validation_loss = numpy.mean(validation_losses)
125. print(
126. ‘epoch %i, minibatch %i/%i, validation error %f %%‘ %
127. (
128. epoch,
129. minibatch_index + 1,
130. n_train_batches,
131. this_validation_loss * 100.
132. )
133. )
134. #当前验证误差比之前的都小，则更新best_validation_loss，以及对应的best_iter，并且在tsetdata上进行test
135. if this_validation_loss < best_validation_loss:
136. if (
137. this_validation_loss < best_validation_loss *
138. improvement_threshold
139. ):
140. patience = max(patience, iter * patience_increase)
141. best_validation_loss = this_validation_loss
142. best_iter = iter
143. test_losses = [test_model(i) for i
144. in xrange(n_test_batches)]
145. test_score = numpy.mean(test_losses)
146. print((‘     epoch %i, minibatch %i/%i, test error of ‘
147. ‘best model %f %%‘) %
148. (epoch, minibatch_index + 1, n_train_batches,
149. test_score * 100.))
150. #patience小于等于iter，则终止训练
151. if patience <= iter:
152. done_looping = True
153. break
154. end_time = time.clock()
155. print((‘Optimization complete. Best validation score of %f %% ‘
156. ‘obtained at iteration %i, with test performance %f %%‘) %
157. (best_validation_loss * 100., best_iter + 1, test_score * 100.))
158. print >> sys.stderr, (‘The code for file ‘ +
159. os.path.split(__file__)[1] +
160. ‘ ran for %.2fm‘ % ((end_time - start_time) / 60.))

文章完，经详细注释的代码：放在我的github地址上，可下载。

如果有任何错误，或者有说不清楚的地方，欢迎评论留言。