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

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 plaincopy

  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 plaincopy

  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(
  25.                 rng.uniform(
  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
  31.             )
  32.             if activation == theano.tensor.nnet.sigmoid:
  33.                 W_values *= 4
  34.             W = theano.shared(value=W_values, name=’W’, borrow=True)
  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 plaincopy

  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 plaincopy

  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 plaincopy

  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 plaincopy

  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.))
知识付费项目

2021欧洲杯赛程时间表

2021-12-21 21:46:36

知识付费项目

老外发邮件常说“TBD”是什么意思?不知道你就完蛋了

2021-12-21 21:51:09

个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索
普人特福的博客cnzz&51la for wordpress,cnzz for wordpress,51la for wordpress