1 MLP基本结构
最典型的MLP（Multilayer perceptron）包括包括三层输入层、隐层和输出层，MLP神经网络不同层之间是全连接的（全连接的意思就是：上一层的任何一个神经元与下一层的所有神经元都有连接）。
输入层没什么好说，你输入什么就是什么，比如输入是一个 n x n_{x} nx维向量，就有 n x n_{x} nx个神经元。
隐藏层的神经元怎么得来？首先它与输入层是全连接的，假设输入层用向量 x x x表示，则隐藏层的输出就是
f ( W [ 1 ] T x + b [ 1 ] ) f({W^{[1]}}^Tx+b^{[1]}) f(W[1]Tx+b[1])， W [ 1 ] W^{[1]} W[1]是权重（也叫连接系数）， b [ 1 ] b^{[1]} b[1]是偏置，函数 f f f 可以是常用的 s i g m o i d sigmoid sigmoid函数或者 t a n h tanh tanh函数。
s
i
g
m
o
i
d
(
a
)
=
1
1
+
e
−
a
t
a
n
h
(
a
)
=
e
a
−
e
−
a
e
a
+
e
−
a
sigmoid(a)=\frac{1}{1+e^{-a}} \\ tanh(a)=\frac{e^a-e^{-a}}{e^a+e^{-a}}
sigmoid(a)=1+e−a1tanh(a)=ea+e−aea−e−a
最后就是输出层，输出层与隐藏层是什么关系？其实隐藏层到输出层可以看成是一个多类别的逻辑回归，也即softmax回归，所以输出层的输出就是
s
o
f
t
m
a
x
(
W
[
2
]
T
a
[
1
]
+
b
[
2
]
)
softmax({W^{[2]}}^Ta^{[1]}+b^{[2]})
softmax(W[2]Ta[1]+b[2])，
a
[
1
]
a^{[1]}
a[1]表示隐藏层的输出
f
(
W
[
1
]
T
x
+
b
[
1
]
)
f({W^{[1]}}^Tx+b^{[1]})
f(W[1]Tx+b[1])。
MLP整个模型就是这样子的，上面说的这个三层的MLP用公式总结起来就是，函数 G G G是 s o f t m a x softmax softmax。
F
(
X
)
=
G
(
b
[
2
]
+
W
[
2
]
T
(
f
(
b
[
1
]
+
W
[
1
]
T
x
)
)
)
F(X)=G(b^{[2]}+{W^{[2]}}^T(f(b^{[1]}+{W^{[1]}}^Tx)))
F(X)=G(b[2]+W[2]T(f(b[1]+W[1]Tx)))
由此可知，神经网络主要有三个基本要素：权重、偏置和激活函数
权重：神经元之间的连接强度由权重表示，权重的大小表示可能性的大小。
偏置：偏置的设置是为了正确分类样本，是模型中一个重要的参数，即保证通过输入算出的输出值不能随便激活。
激活函数：起非线性映射的作用，其可将神经元的输出幅度限制在一定范围内，一般限制在（－1～1）或（0～1）之间。最常用的激活函数是 S i g m o i d Sigmoid Sigmoid函数，其可将（－∞，＋∞）的数映射到（0～1）的范围内,一般用于二分类。
激活函数还有tanh和ReLU等函数，tanh是 S i g m o i d Sigmoid Sigmoid函数的变形，tanh的均值是0，在实际应用中有比Sigmoid更好的效果；ReLU是近来比较流行的激活函数，当输入信号小于0时，输出为0；当输入信号大于0时，输出等于输入；具体采用哪种激活函数需视具体情况定。还有leaky ReLU函数，左边不为0，值很小
为什么使用激活函数？
- 不使用激活函数，每一层输出都是上层输入的线性函数，无论神经网络有多少层，输出都是输入的线性组合。
- 使用激活函数，能够给神经元引入非线性因素，使得神经网络可以任意逼近任何非线性函数，这样神经网络就可以利用到更多的非线性模型中。
激活函数需要具备以下几点性质:
- 连续并可导（允许少数点上不可导）的非线性函数。可导的激活函数可以直接利用数值优化的方法来学习网络参数。
- 激活函数及其导函数要尽可能的简单，有利于提高网络计算效率。
- 激活函数的导函数的值域要在一个合适的区间内，不能太大也不能太小，否则会影响训练的效率和稳定性。
因此，MLP所有的参数就是各个层之间的连接权重以及偏置，包括 W [ 1 ] T 、 b [ 1 ] 、 W [ 2 ] T 、 b [ 1 ] {W^{[1]}}^T、b^{[1]}、{W^{[2]}}^T、b^{[1]} W[1]T、b[1]、W[2]T、b[1]。对于一个具体的问题，怎么确定这些参数？求解最佳的参数是一个最优化问题，解决最优化问题，最简单的就是梯度下降法了（SGD）：首先随机初始化所有参数，然后迭代地训练，不断地计算梯度和更新参数，直到满足某个条件为止（比如误差足够小、迭代次数足够多时）。这个过程涉及到代价函数、规则化（Regularization）、学习速率（learning rate）、梯度计算等。
2 MLP训练过程
-
所有边的权重随机分配；
-
前向传播：利用训练集中所有样本的输入特征，作为输入层，对于所有训练数据集中的输入，人工神经网络都被激活，然后经过前向传播，得到输出值。
-
反向传播：利用输出值和样本值计算总误差，再利用反向传播来更新权重。
-
重复步骤2~3, 直到输出误差低于制定的标准。
-
上述过程结束后，就得到了一个学习过的MLP网络，该网络被认为是可以接受新输入的。
3 MLP优缺点
①MLP优点
-
高度的并行处理；
-
高度的非线性全局作用；
-
良好的容错性；
-
具有联想记忆功能；
-
非常强的自适应、自学习功能。
②MLP缺点
-
网络的隐含节点个数选取非常难；
-
停止阈值、学习率、动量常数需要采用“trial-and-error”法，极其耗时；
-
学习速度慢；
-
容易陷入局部极值；
-
学习可能会不够充分。
4 MLP经典例子（手写数字识别)
4.1 数字识别介绍
MLP的最经典例子就是数字识别，即我们随便给出一张上面写有数字的图片并作为输入，由它最终给出图片上的数字到底是几。
对于一张写有数字的图片，我们可将其分解为由 28 ＊ 28 ＝ 784 28＊28＝784 28＊28＝784个像素点构成，每个像素点的值在 （ 0 ～ 1 ） （0～1） （0～1）之间，其表示灰度值，值越大该像素点则越亮，越低则越暗，以此表达图片上的数字并将这786个像素点作为神经网络的输入。
而输出则由十个神经元构成，分别表示 （ 0 ～ 9 ） （0～9） （0～9）这十个数字，这十个神经元的值也是在 （ 0 ～ 1 ） （0～1） （0～1）之间，也表示灰度值，但神经元值越大表示从输入经判断后是该数字的可能性越大。
4.2 MLP代码实现
这个代码实现的是一个三层的感知机，但是理解了代码之后，实现n层感知机都不是问题，所以只需理解好这个三层的MLP模型即可。概括地说，MLP的输入层 X X X其实就是我们的训练数据，所以输入层不用实现，剩下的就是“输入层到隐含层”，“隐含层到输出层”这两部分。上面介绍原理时已经说到了，“输入层到隐含层”就是一个全连接层，在下面的代码中我们把这一部分定义为HiddenLayer。“隐含层到输出层”就是一个分类器softmax回归（也有人叫逻辑回归），在下面的代码中我们把这一部分定义为LogisticRegression。
- 导入必要的python模块
主要是numpy、theano，以及python自带的os、sys、time模块，这些模块的使用在下面的程序中会看到。
import os
import sys
import time
import numpy
import theano
import theano.tensor as T
- 定义MLP模型（HiddenLayer+LogisticRegression）
这一部分定义MLP的基本“构件”，即上文一直在提的HiddenLayer和LogisticRegression
（1）HiddenLayer
隐含层我们需要定义连接系数W、偏置b，输入、输出，具体的代码以及解读如下：
class HiddenLayer(object):
def __init__(self, rng, input, n_in, n_out, W=None, b=None,
activation=T.tanh):
"""
注释：
这是定义隐藏层的类，首先明确：隐藏层的输入即input，输出即隐藏层的神经元个数。输入层与隐藏层是全连接的。
假设输入是n_in维的向量（也可以说时n_in个神经元），隐藏层有n_out个神经元，则因为是全连接，
一共有n_in*n_out个权重，故W大小时(n_in,n_out),n_in行n_out列，每一列对应隐藏层的每一个神经元的连接权重。
b是偏置，隐藏层有n_out个神经元，故b时n_out维向量。
rng即随机数生成器，numpy.random.RandomState，用于初始化W。
input训练模型所用到的所有输入，并不是MLP的输入层，MLP的输入层的神经元个数时n_in，而这里的参数input大小是
（n_example,n_in）,每一行一个样本，即每一行作为MLP的输入层。
activation:激活函数,这里定义为函数tanh
"""
self.input = input #类HiddenLayer的input即所传递进来的input
"""
注释：
代码要兼容GPU，则W、b必须使用 dtype=theano.config.floatX,并且定义为theano.shared
另外，W的初始化有个规则：如果使用tanh函数，则在-sqrt(6./(n_in+n_hidden))到sqrt(6./(n_in+n_hidden))之间均
匀抽取数值来初始化W，若是sigmoid函数，则以上再乘4倍。
"""
#如果W未初始化，则根据上述方法初始化。
#加入这个判断的原因是：有时候我们可以用训练好的参数来初始化W，见我的上一篇文章。
if W is None:
W_values = numpy.asarray(
rng.uniform(
low=-numpy.sqrt(6. / (n_in + n_out)),
high=numpy.sqrt(6. / (n_in + n_out)),
size=(n_in, n_out)
),
dtype=theano.config.floatX # 为了与 theano 设置的浮点数精度保持一致
)
if activation == theano.tensor.nnet.sigmoid:
W_values *= 4
W = theano.shared(value=W_values, name='W', borrow=True) # 将变量设置为全局变量，其值可以在多个函数中共用
if b is None:
b_values = numpy.zeros((n_out,), dtype=theano.config.floatX)
b = theano.shared(value=b_values, name='b', borrow=True)
#用上面定义的W、b来初始化类HiddenLayer的W、b
self.W = W
self.b = b
#隐含层的输出
lin_output = T.dot(input, self.W) + self.b
self.output = (
lin_output if activation is None
else activation(lin_output)
)
#隐含层的参数
self.params = [self.W, self.b]
b. LogisticRegression
逻辑回归（softmax回归），代码详解如下。
（如果你想详细了解softmax回归，可以参考： DeepLearning tutorial（1）Softmax回归原理简介+代码详解）
"""
定义分类层，Softmax回归
在deeplearning tutorial中，直接将LogisticRegression视为Softmax，
而我们所认识的二类别的逻辑回归就是当n_out=2时的LogisticRegression
"""
#参数说明：
#input，大小就是(n_example,n_in)，其中n_example是一个batch的大小，
#因为我们训练时用的是Minibatch SGD，因此input这样定义
#n_in,即上一层(隐含层)的输出
#n_out,输出的类别数
class LogisticRegression(object):
def __init__(self, input, n_in, n_out):
#W大小是n_in行n_out列，b为n_out维向量。即：每个输出对应W的一列以及b的一个元素。
self.W = theano.shared(
value=numpy.zeros(
(n_in, n_out),
dtype=theano.config.floatX
),
name='W',
borrow=True
)
self.b = theano.shared(
value=numpy.zeros(
(n_out,),
dtype=theano.config.floatX
),
name='b',
borrow=True
)
#input是(n_example,n_in)，W是（n_in,n_out）,点乘得到(n_example,n_out)，加上偏置b，
#再作为T.nnet.softmax的输入，得到p_y_given_x
#故p_y_given_x每一行代表每一个样本被估计为各类别的概率
#PS：b是n_out维向量，与(n_example,n_out)矩阵相加，内部其实是先复制n_example个b，
#然后(n_example,n_out)矩阵的每一行都加b
self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
#argmax返回最大值下标，因为本例数据集是MNIST，下标刚好就是类别。axis=1表示按行操作。
self.y_pred = T.argmax(self.p_y_given_x, axis=1)
#params，LogisticRegression的参数
self.params = [self.W, self.b]
ok！这两个基本“构件”做好了，现在我们可以将它们“组装”在一起。
我们要三层的MLP，则只需要HiddenLayer+LogisticRegression，
如果要四层的MLP，则为HiddenLayer+HiddenLayer+LogisticRegression…以此类推。
下面是三层的MLP：
#3层的MLP
class MLP(object):
def __init__(self, rng, input, n_in, n_hidden, n_out):
self.hiddenLayer = HiddenLayer(
rng=rng,
input=input,
n_in=n_in,
n_out=n_hidden,
activation=T.tanh
)
#将隐含层hiddenLayer的输出作为分类层logRegressionLayer的输入，这样就把它们连接了
self.logRegressionLayer = LogisticRegression(
input=self.hiddenLayer.output,
n_in=n_hidden,
n_out=n_out
)
#以上已经定义好MLP的基本结构，下面是MLP模型的其他参数或者函数
#规则化项：常见的L1、L2_sqr
self.L1 = (
abs(self.hiddenLayer.W).sum()
+ abs(self.logRegressionLayer.W).sum()
)
self.L2_sqr = (
(self.hiddenLayer.W ** 2).sum()
+ (self.logRegressionLayer.W ** 2).sum()
)
#损失函数Nll（也叫代价函数）
self.negative_log_likelihood = (
self.logRegressionLayer.negative_log_likelihood
)
#误差
self.errors = self.logRegressionLayer.errors
#MLP的参数
self.params = self.hiddenLayer.params + self.logRegressionLayer.params
# end-snippet-3
MLP类里面除了隐含层和分类层，还定义了损失函数、规则化项，这是在求解优化算法时用到的。
-
将MLP应用于MNIST（手写数字识别）
上面定义好了一个三层的MLP，接下来使用它在MNIST数据集上分类，MNIST是一个手写数字0～9的数据集。
首先定义加载数据 mnist.pkl.gz 的函数load_data()：
""" 加载MNIST数据集 """ def load_data(dataset): # dataset是数据集的路径，程序首先检测该路径下有没有MNIST数据集，没有的话就下载MNIST数据集 #这一部分就不解释了，与softmax回归算法无关。 data_dir, data_file = os.path.split(dataset) if data_dir == "" and not os.path.isfile(dataset): # Check if dataset is in the data directory. new_path = os.path.join( os.path.split(__file__)[0], "..", "data", dataset ) if os.path.isfile(new_path) or data_file == 'mnist.pkl.gz': dataset = new_path if (not os.path.isfile(dataset)) and data_file == 'mnist.pkl.gz': import urllib origin = ( 'http://www.iro.umontreal.ca/~lisa/deep/data/mnist/mnist.pkl.gz' ) print 'Downloading data from %s' % origin urllib.urlretrieve(origin, dataset) print '... loading data' #以上是检测并下载数据集mnist.pkl.gz，不是本文重点。下面才是load_data的开始 #从"mnist.pkl.gz"里加载train_set, valid_set, test_set，它们都是包括label的 #主要用到python里的gzip.open()函数,以及 cPickle.load()。 #‘rb’表示以二进制可读的方式打开文件 f = gzip.open(dataset, 'rb') train_set, valid_set, test_set = cPickle.load(f) f.close() #将数据设置成shared variables，主要时为了GPU加速，只有shared variables才能存到GPU memory中 #GPU里数据类型只能是float。而data_y是类别，所以最后又转换为int返回 def shared_dataset(data_xy, borrow=True): data_x, data_y = data_xy shared_x = theano.shared(numpy.asarray(data_x, dtype=theano.config.floatX), borrow=borrow) shared_y = theano.shared(numpy.asarray(data_y, dtype=theano.config.floatX), borrow=borrow) # borrow为true时，值计算后可以被覆盖 return shared_x, T.cast(shared_y, 'int32') # 转换为int32类型 test_set_x, test_set_y = shared_dataset(test_set) valid_set_x, valid_set_y = shared_dataset(valid_set) train_set_x, train_set_y = shared_dataset(train_set) rval = [(train_set_x, train_set_y), (valid_set_x, valid_set_y), (test_set_x, test_set_y)] return rval加载了数据，可以开始训练这个模型了，以下就是主体函数test_mlp()，将MLP用在MNIST上：
#test_mlp是一个应用实例，用梯度下降来优化MLP，针对MNIST数据集 def test_mlp(learning_rate=0.01, L1_reg=0.00, L2_reg=0.0001, n_epochs=10, dataset='mnist.pkl.gz', batch_size=20, n_hidden=500): """ 注释： learning_rate学习速率，梯度前的系数。 L1_reg、L2_reg：正则化项前的系数，权衡正则化项与Nll项的比重 代价函数=Nll+L1_reg*L1或者L2_reg*L2_sqr n_epochs：迭代的最大次数（即训练步数），用于结束优化过程 dataset：训练数据的路径 n_hidden:隐藏层神经元个数 batch_size=20，即每训练完20个样本才计算梯度并更新参数 """ #加载数据集，并分为训练集、验证集、测试集。 datasets = load_data(dataset) train_set_x, train_set_y = datasets[0] valid_set_x, valid_set_y = datasets[1] test_set_x, test_set_y = datasets[2] #shape[0]获得行数，一行代表一个样本，故获取的是样本数，除以batch_size可以得到有多少个batch n_train_batches = train_set_x.get_value(borrow=True).shape[0] / batch_size n_valid_batches = valid_set_x.get_value(borrow=True).shape[0] / batch_size n_test_batches = test_set_x.get_value(borrow=True).shape[0] / batch_size ###################### # BUILD ACTUAL MODEL # ###################### print '... building the model' #index表示batch的下标，标量 #x表示数据集 #y表示类别，一维向量 index = T.lscalar() x = T.matrix('x') y = T.ivector('y') rng = numpy.random.RandomState(1234) #生成一个MLP，命名为classifier classifier = MLP( rng=rng, input=x, n_in=28 * 28, n_hidden=n_hidden, n_out=10 ) #代价函数，有规则化项 #用y来初始化，而其实还有一个隐含的参数x在classifier中 cost = ( classifier.negative_log_likelihood(y) + L1_reg * classifier.L1 + L2_reg * classifier.L2_sqr ) #这里必须说明一下theano的function函数，givens是字典，其中的x、y是key，冒号后面是它们的value。 #在function被调用时，x、y将被具体地替换为它们的value，而value里的参数index就是inputs=[index]这里给出。 #下面举个例子： #比如test_model(1)，首先根据index=1具体化x为test_set_x[1 * batch_size: (1 + 1) * batch_size]， #具体化y为test_set_y[1 * batch_size: (1 + 1) * batch_size]。然后函数计算outputs=classifier.errors(y)， #这里面有参数y和隐含的x，所以就将givens里面具体化的x、y传递进去。 test_model = theano.function( inputs=[index], outputs=classifier.errors(y), givens={ x: test_set_x[index * batch_size:(index + 1) * batch_size], y: test_set_y[index * batch_size:(index + 1) * batch_size] } ) validate_model = theano.function( inputs=[index], outputs=classifier.errors(y), givens={ x: valid_set_x[index * batch_size:(index + 1) * batch_size], y: valid_set_y[index * batch_size:(index + 1) * batch_size] } ) #cost函数对各个参数的偏导数值，即梯度，存于gparams gparams = [T.grad(cost, param) for param in classifier.params] #参数更新规则 #updates[(),(),()....],每个括号里面都是(param, param - learning_rate * gparam)，即每个参数以及它的更新公式 updates = [ (param, param - learning_rate * gparam) for param, gparam in zip(classifier.params, gparams) ] train_model = theano.function( inputs=[index], outputs=cost, updates=updates, givens={ x: train_set_x[index * batch_size: (index + 1) * batch_size], y: train_set_y[index * batch_size: (index + 1) * batch_size] } ) ############### # 开始训练模型 # ############### print '... training' patience = 10000 patience_increase = 2 #提高的阈值，在验证误差减小到之前的0.995倍时，会更新best_validation_loss improvement_threshold = 0.995 #这样设置validation_frequency可以保证每一次epoch都会在验证集上测试。 validation_frequency = min(n_train_batches, patience / 2) best_validation_loss = numpy.inf best_iter = 0 test_score = 0. start_time = time.clock() #epoch即训练步数，每个epoch都会遍历所有训练数据 epoch = 0 done_looping = False #下面就是训练过程了，while循环控制的时步数epoch，一个epoch会遍历所有的batch，即所有的图片。 #for循环是遍历一个个batch，一次一个batch地训练。for循环体里会用train_model(minibatch_index)去训练模型， #train_model里面的updatas会更新各个参数。 #for循环里面会累加训练过的batch数iter，当iter是validation_frequency倍数时则会在验证集上测试， #如果验证集的损失this_validation_loss小于之前最佳的损失best_validation_loss， #则更新best_validation_loss和best_iter，同时在testset上测试。 #如果验证集的损失this_validation_loss小于best_validation_loss*improvement_threshold时则更新patience。 #当达到最大步数n_epoch时，或者patience<iter时，结束训练 while (epoch < n_epochs) and (not done_looping): epoch = epoch + 1 for minibatch_index in xrange(n_train_batches):#训练时一个batch一个batch进行的 minibatch_avg_cost = train_model(minibatch_index) # 已训练过的minibatch数，即迭代次数iter iter = (epoch - 1) * n_train_batches + minibatch_index #训练过的minibatch数是validation_frequency倍数，则进行交叉验证 if (iter + 1) % validation_frequency == 0: # compute zero-one loss on validation set validation_losses = [validate_model(i) for i in xrange(n_valid_batches)] this_validation_loss = numpy.mean(validation_losses) print( 'epoch %i, minibatch %i/%i, validation error %f %%' % ( epoch, minibatch_index + 1, n_train_batches, this_validation_loss * 100. ) ) #当前验证误差比之前的都小，则更新best_validation_loss，以及对应的best_iter，并且在tsetdata上进行test if this_validation_loss < best_validation_loss: if ( this_validation_loss < best_validation_loss * improvement_threshold ): patience = max(patience, iter * patience_increase) best_validation_loss = this_validation_loss best_iter = iter test_losses = [test_model(i) for i in xrange(n_test_batches)] test_score = numpy.mean(test_losses) print((' epoch %i, minibatch %i/%i, test error of ' 'best model %f %%') % (epoch, minibatch_index + 1, n_train_batches, test_score * 100.)) #patience小于等于iter，则终止训练 if patience <= iter: done_looping = True break end_time = time.clock() print(('Optimization complete. Best validation score of %f %% ' 'obtained at iteration %i, with test performance %f %%') % (best_validation_loss * 100., best_iter + 1, test_score * 100.)) print >> sys.stderr, ('The code for file ' + os.path.split(__file__)[1] + ' ran for %.2fm' % ((end_time - start_time) / 60.))
扫一扫
800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
