感知机

感知机是二分类的线性分类模型，输入为实例的特征向量，输出为实例的类别（取+1和-1）。感知机对应于输入空间中将实例划分为两类的分离超平面。感知机旨在求出该超平面，为求得超平面导入了基于误分类的损失函数，利用梯度下降法对损失函数进行最优化（最优化）。感知机的学习算法具有简单而易于实现的优点，分为原始形式 和 对偶形式。感知机预测是用学习得到的感知机模型对新的实例进行预测的，因此属于判别模型。感知机是一种线性分类模型，只适应于线性可分的数据，对于线性不可分的数据模型训练是不会收敛的。

感知机模型

假设输入空间(特征向量)是 x∈Rn

输出空间为 Y={−1，+1}，输入 x∈X表示表示实例的特征向量，对应于输入空间的点，输出 y∈Y

表示实例的类别，则由输入空间到输出空间的表达形式为：

f(x)=sign(w⋅x+b)

该函数称为感知机，其中w和b 称为模型的参数，w∈Rn称为权值，b 称为偏置,w⋅x 表示 w和x 的内积

这里

sign(x)={+1,x>0−1,x<0

如果我们将sign称之为激活函数的话，感知机与logistic regression的差别就是感知机激活函数是sign，logistic regression的激活函数是sigmoid。sign(x)将大于0的分为1，小于0的分为-1；sigmoid将大于0.5的分为1，小于0.5的分为0。因此sign又被称为单位阶跃函数，logistic regression也被看作是一种概率估计。

在神经网络以及DeepLearning中会使用其他如tanh，relu等其他激活函数。

感知机的学习策略

如下图： 线性可分数据集

 




 

对于一个给定的线性可分的数据集，如上面的数据点，红色代表正类，蓝色代表负类，感知机的主要工作就是寻找一个线性可分的超平面 S：{w⋅x+b=0}

, 该超平面能够将所有的正类和负类完全划分到超平面的两侧。而这就是上图中的红色直线，也就是说，感知机算法实际上就是找一条直线将数据集进行正确划分。

如果数据集可以被一个超平面完全划分，则称该数据集是线性可分的数据集，否则称为线性不可分的数据集，如下图：

非线性可分数据集

感知机分类效果：

 




 

logistic regression分类效果：

 




 

为了寻找上面那条能够将数据集完全划分的超平面 S:w⋅x+b=0

我们需要确定一个学习策略，也就是常说的loss function 以及梯度下降法迭代求解。

为了使用梯度下降法求解 w和b

，我们的loss function必须是 w和b 的连续可导函数，因此可以选择loss function为：误分类点到超平面 S 的总距离。令输入 x0 到超平面 S 的距离为 1||w|||w⋅x0+b| ，其中 ||w|| 为 w 的L2

范数。

对误分类点(xi,yi)

来说，有 −yi(w⋅xi+b)>0

，则可得loss function为：

L(w,b)=−1||w||∑xi∈Myi(w⋅xi+b)

 

测重点讲下损失函数【

1.损失函数

根据w与b，定义一个损失函数，并使得损失函数最小化。首先，Rn空间中任意一点x0

到超平面的距离为

1||w|||ωx0+b|

学习过程中，当点发生错误分类时，yi与(ωx0+b)的符号相反，且其乘积为1。那么假设超平面S的所有错误分类的点的集合为M，那么所有错误分类的点到超平面的距离总和为

−1||ω||∑xi∈Myi(ωxi+b)

不考虑||ω||，即得到了感知机学习的损失函数。对于给定的训练集T={(x1,y1),(x2,y2)...(xN,yN)}感知机sign(ωx+b)学习的损失函数定义为

L(ω,b)=−∑xi∈Myi(ωxi+b)



显然，损失函数是非负的，并且错误分类的点越少，错误分类的点离超平面的距离越小，损失函数的值越小。一个特定的样本点的损失函数，错误分类时是ω,b的线性函数，在正确分类时是0，因此，损失函数是ω,b的连续可到函数。

】

感知机学习算法及对偶形式【

1.原始形式

对于给定的训练集T={(x1,y1),(x2,y2)...(xN,yN)}求解参数ω,b

是损失函数极小化。

minω,bL(ω,b)=−∑xi∈Myi(ωxi+b)



采用随机梯度下降算法，首先确定一个初始值，损失函数的梯度表示为：

∇ωL(ω,b)=−∑xi∈Myixi

 

∇bL(ω,b)=−∑xi∈Myi



则根据梯度下降规则， 当出现一个错误分类点时，更新ω=ω+ηyixi， b=b+ηyi其中η为学习率，通过迭代使得损失函数L(ω,b)不断减小，直至为零。

 

2.对偶形式

更新ω=ω+ηyixi

，b=b+ηyi其中η为学习率。逐步修改参数的过程中，易知对于一个点(xi,yi)，其对参数的增量分别是αiyixi与αiyi，这里的αi=niη

.

则有

ω=∑i=1Nαiyixi

b=∑i=1Nαiyi



感知机的模型可表述为f(x)=sign(∑Nj=1αjyjxjx+b)其中α=(α1,α2...αN)T

对于一个实例(xi,yi)如果yi∑Nj=1αjyjxjx+b<=0即发生错误分类时，更新αi=αi+η, b=b+ηyi

在算法过程中，涉及到计算xixj，可以预处理Gram矩阵存储任意两个训练实例向量的内积。

 

感知机作为一个二分类线性分类器，同时也是支持向量机和神经网络的基础，可以推广到多分类和非线性分类。

】

 



感知机的对偶形式

基本思想：

将 w

和 b 表示为实例 xi 和标记 yi线性组合的形式，通过求解其系数而求得 w、b 。假设 w0,b0为0，对误分类点(xi,yi)

通过

w=w+ηyixi

b=b+ηyi

逐步修改 w,b

，设修改 n 次，则 w,b 关于(xi,yi) 的增量分别为 αiyixi 和 αiyi, 其中αi=niη ，则最后学习到的 w,b

可以分别表示为

w=∑i=1Nαiyixi

b=∑i=1Nαiyi

 

这里，αi≥0,=1,2,⋯N

, αi=niη ,ni 的意义是样本 i 被误分的次数，所以当 η=1 时，表示第 i 个样本由于被误分而更新的次数，实例点更新次数越多，表明它距离分离超平面越近，也就越难正确分类。

参考文章:https://blog.csdn.net/llp1992/article/details/50594349#%E6%84%9F%E7%9F%A5%E6%9C%BA%E7%9A%84%E5%8E%9F%E5%A7%8B%E5%BD%A2%E5%BC%8F

 

1.感知机与多层感知机
1.1 门
与门：实现逻辑“乘”运算 y=AB

与门真值表




A
B
y




0
0
0


0
1
0


1
0
0


1
1
1


非门：实现逻辑非，一对一输出

非门真值表




A
y




0
1


1
0


或门：实现逻辑“和”运算 y=A+B

或门真值表




A
B
y




0
0
0


1
0
1


0
1
1


1
1
1


与非门：先与后非

与非门真值表




A
B
y




0
0
1


0
1
1


1
0
1


1
1
0


1.2 感知机


感知机接受多个输入信号，输出一个信号，x1,x2是输入信号，y是输出信号，w1，w2是权重，输出y=x1w1+x2w2,当这个总和超过了某个界限值时，才会输出1。这也被称为“神经元被激活”。这里将这个界限值称为阈值，用θ表示





感知机的局限性在于它只能表示由一条直分割的空间，异或门的曲线无法用感知机表示



异或门无法用直线分割，可以用曲线分割开



数字电路中异或门可以通过

组合与门，与非门，或门实现异或门，组合真值表如下：




x1
x2
s1（x1,x2与非门）
s2（x1,x2或门）
y(s1,s2与门)




0
0
1
0
0


0
1
1
1
1


1
0
1
1
1


1
1
0
1
0


下面用感知机的方法表示：


上图中有s1和s2 两层感知机，叠加了多层的感知机也称为多层感知机。

常见的多层感知机（神经网络）的图：



单层感知机与多层感知机的区别：

<1>. 多层感知机在输入层与输出层之间多了一层隐藏层

<2>. 每层神经元与下一层神经元全互连

<3>. 隐藏层也有激活功能的神经元
2. Tensorflow实现多层感知机
tensorflow训练神经网络的4个步骤
step1:定义计算公式
隐藏层权重初始化，激活函数的选择
step2:定义损失函数 及选择优化器
损失函数有平方误差，交叉信息熵等，选择优化器，学习率
step3:训练模型
训练轮数，batch的数量，batch的大小，dropout的keep_prob的设置
step4:用测试集对模型进行准确率评测
如果有keep_prob则设为1即用全部特征进行预测，用tf.equal判断预测正确的样本，tf.cast将[True,False]转为0，1,tf.reduce_mean计算均值
实现代码：
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf

mnist= input_data.read_data_sets("MNIST_DATA/",one_hot=True)
sess = tf.InteractiveSession()
'''
下面给隐含层的参数设置Variable进行初始化
in_units:输入节点数
h1_units:隐含层的输出节点数(设为300)
W1，b1:隐含层权重与偏置
将权重初始化为截断的正太分布，标准差为0.1(偏置全为0)，tf.truncated_normal([in_units,h1_units],stddev=0.1)
因为模型使用的激活函数是ReLU,所以需要使用正态分布给参数加一点噪声来打破完全对称，并且避免0梯度
W2，b2:输出层权重和偏置（全部设为0）
'''
in_units = 784
h1_units =300
W1 = tf.Variable(tf.truncated_normal([in_units,h1_units],stddev=0.1))
b1 = tf.Variable(tf.zeros([h1_units]))
W2 = tf.Variable(tf.zeros([h1_units,10]))
b2 = tf.Variable(tf.zeros([10]))

'''
定义输入x的placeholder，在训练和预测时，Dropout的比率Keep_prob是不一样的，通常在训练时小于1，而预测时等于1，所以把Dropout的比率作为计算图的输入，并定义为一个placeholder
'''
x = tf.placeholder(tf.float32,[None,in_units])
keep_prob = tf.placeholder(tf.float32)
'''
定义模型结构:
step1：首先需要一个隐含层，命名为hidden1，可以通过tf.nn.relu(tf.matmul(x,w1) + b1)实现一个激活函数为Relu的隐含层，
这个隐含层的计算公式就是y=relu(W1X+b1)
step2:用tf.nn.dropout实现dropout功能，随机将一部分节点设为0，
keep_prob:保留数据，即不设为0的比例，训练时小于1，可以制造随机性，预测时等于1，使用全部特征来预测样本
'''

hidden1 = tf.nn.relu(tf.matmul(x,W1) + b1)
hidden1_drop = tf.nn.dropout(hidden1,keep_prob)
y = tf.nn.softmax(tf.matmul(hidden1_drop,W2) + b2)

'''
定义损失函数和选择优化器
'''
y_=tf.placeholder(tf.float32,[None,10])   #10维，是哪个数字对应的索引就是1
cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_*tf.log(y),reduction_indices=[1]))
train_step = tf.train.AdagradOptimizer(0.3).minimize(cross_entropy)

'''
开始训练
共300个batch,每个batch包含100个样本，训练时保留75%的节点
'''
tf.global_variables_initializer().run()
for i in range(300):
    batch_xs,batch_ys=mnist.train.next_batch(100)
    train_step.run({x:batch_xs,y_:batch_ys,keep_prob:0.75})
    
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))   #tf.argmax(y,1) y矩阵的每一行最大值的索引
accuracy= tf.reduce_mean(tf.cast(correct_prediction,tf.float32))
print(accuracy.eval({x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0}))
''' 

关于感知机

ok lets go。


感知机是线性分类模型，划重点注意哦，是线性的分类模型。也就是说，如果你拿感知机去分类线性不可分的数据集的话，它的效果想必垂泪。
因为近期看到相关算法的缘故来写一片感知机的文章，主要介绍一下这是个什么东西以及它能用来干什么。
就我来说最考试接触到感知机是在学习神经网络的时候，神经网络中的每一个点就能看做是一个感知机。


上图大概就是感知机的构造了。了解神经网络的同学肯定了解到这就是网络中的一个节点，左边是输入，肉便是输出，将左边的向量输入乘以权值向量加上偏差（图中未给出）再通过激活函数便是输出了。我们在看一下感知机的公式：




我们的公式1即可视为感知机的机理，公式二为激活函数。公式1与上图中感知机的结构相对应。

我们再来介绍下数据集，使用感知机来分类的数据集为线性可分的数据，可以被分为两类，我们将其标注为+1和-1.感知机所做的就是将数据中的特征放入到公式1当中，得出的结果若为+1，则分为类别1，结果为-1，则分为类别2.这差不多就是我们使用感知机模型的方法了，当然这是感知机模型以及训练完毕之后的用法。换而言之，我们要先训练感知机模型，使其能够达到分类我们数据的能力时再来使用它。ml中的所有学习算法几乎都具有这样的特点。



感知机所做的在上图所示的数据中可以视为划分一条线来分类数据。（在高维数据集中实则为划分一个超平面来分类数据）

ok 现在我们来看看这个模型要怎么训练。首先我们看看他需要训练的是哪些东西，是哪些参数。我们所需要训练的参数即是在公式一中的w（权重，weight）以及b（偏差，bias）。得到这两个参数之后，我们可以看到感知机就能够运作了，只需要输入数据即可。

现在我们来简单讨论如何训练这两个参数，这就是感知机算法。



我们将这作为我们的数据，对应于上图我们的数据中的xi是两维的，相对应的w也是两维。我们需要从数据中学习如何制定w和b来使得模型对数据的分类效果达到最佳。感知机的分类思想主要可以简单的表述为通过迭代更新w和b使得被误分类的的数据点距离我们的分类超平面的距离尽可能的小。怎么来理解这句话，我们可以这样想：感知机所做的是试图找到一个超平面来完美的把数据集分割为两个类别，一个类别在超平面的一边，而另一个类别的数据则在超平面的另一边，超平面规定这两边的数据都有相对的类别，比如说超平面上方为类别一下方为类别二，那么实际使用该感知机分类完毕后处在超平面上方的数据全为类别一，下方全为类别二。感知机模型希望能找到这样一个超平面，若这样的平面被找到，分类问题（在当前数据集）便被解决了。那要如何找到这样一个平面呢？简而言之就是当我们取数据集中的一个数据点，而此数据点经过我们的感知机模型之后的输出显示他是被误分类的时候（y_pred与y_label不一致），此时他在超分类平面的一边，且是错误的一边，我们则通过修改超平面来使得该被误分类的数据点能够更接近超平面，因为它处在错误的一面，则他离超平面越近则超平面的正确性就相对而言的更高一些。这样说相信大家都能理解了。而经过不断从数据集中取出数据，判断其分类正确与否，再修正超平面的迭代过程最终就可使得该超平面接近于理想中正确完美的那个平面。下面我们来介绍这一步骤是怎样通过数学的方法实现的，当然了，简单讲讲。

如上所示为点到平面的距离公式，而在我们的感知机算法中推广到更高纬时：


他差不多是这样的。其中||w||指的是w的l2范数（母鸡的可以先行了解）。我们所要的误分类的点距离超平面的距离则可以展示如下：



其中yi是数据集中每一个数据点的对应的正确的标签（y_label），xi是数据点的特征。就上式来说，若yi是1，而（w*xi+b）是-1，这个式子他就是大于0的，也就是说误分类的点上式值为正，相反正确分类的点的值为负（自证）。所以将所有的误分类的点代入其中便可得出所有误分类的点到超平面的距离集合，相加即是距离和，如下所示：



上式中输入的xi都为被误分类的点，而输出即是误分类的点距离超平面的距离之和。理论上我们只要想办法将这个式子最小化，我们的目的就达到了（该式子>=0），因为该式子输入元为误分类的店，当其值最小化（为0时），即不存在误分类的点，即是超平面完美，分类任务完成。
ok 现在介绍如何来使得这个式子最小化。（实际中为了方便我们将前面的||w||直接去掉，只看后半部分的式子）。

也就是这么个东西，这个式子可以看出是感知机模型的损失函数，也就是我们要尽力最小化的函数。
要最小化这个式子，我们使用的是梯度下降算法（母鸡可以自行了解一哈）。

w与b的梯度如上所示，接下来我们要做的便是迭代优化。从数据集中抽取数据点，判断其是否误分类，若不是怎接着抽下一个，若是则求其梯度，更新w与b，直到损失函数接近于最小值。
更新w与b如下式：


文章到这儿就差不多了，感知机做的事主要就是根据线性可分的数据集来构造一个超平面来分类数据，若果你看懂了那就最好，如果不懂或者有疑惑或者有啥想法探讨，可以email我：zlh9584@gmail.com

愿你前程似镜，世界和平。

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

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

                                       

 

           从上图可以看到，多层感知机层与层之间是全连接的。多层感知机最底层是输入层，中间是隐藏层，最后是输出层。 

隐藏层的神经元怎么得来？首先它与输入层是全连接的，假设输入层用向量X表示，则隐藏层的输出就是 f (W1X+b1)，W1是权重（也叫连接系数），b1是偏置，函数f 可以是常用的sigmoid函数或者tanh函数：

 注：神经网络中的Sigmoid型激活函数：


       1.  为嘛使用激活函数？



            a. 不使用激活函数，每一层输出都是上层输入的线性函数，无论神经网络有多少层，输出都是输入的线性组合。

            b. 使用激活函数，能够给神经元引入非线性因素，使得神经网络可以任意逼近任何非线性函数，这样神经网络就可以利用到更多的非线性模型中。



 激活函数需要具备以下几点性质:

            1. 连续并可导（允许少数点上不可导）的非线性函数。可导的激活函数可以直接利用数值优化的方法来学习网络参                    数。

            2. 激活函数及其导函数要尽可能的简单，有利于提高网络计算效率。

           3. 激活函数的导函数的值域要在一个合适的区间内，不能太大也不能太小，否则会影响训练的效率和稳定性。 


      2. sigmod 函数

                                                

                    

导数为：

                            

                 

  3 . Tanh 函数

                                                     

                                                

            

取值范围为[-1,1]

tanh在特征相差明显时的效果会很好，在循环过程中会不断扩大特征效果。

与sigmod的区别是 tanh 是0 的均值，因此在实际应用中tanh会比sigmod更好。

在具体应用中，tanh函数相比于Sigmoid函数往往更具有优越性，这主要是因为Sigmoid函数在输入处于[-1,1]之间时，函数值变 化敏感，一旦接近或者超出区间就失去敏感性，处于饱和状态。

 

       最后就是输出层，输出层与隐藏层是什么关系？

      其实隐藏层到输出层可以看成是一个多类别的逻辑回归，也即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模块，这些模块的使用在下面的程序中会看到。

import os
import sysimport time
 
import numpy
 
import theano
import theano.tensor as T



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

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

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
            )
            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]


 LogisticRegression

  逻辑回归（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类里面除了隐含层和分类层，还定义了损失函数、规则化项，这是在求解优化算法时用到的。

Ref：

 1.  https://blog.csdn.net/m0_38045485/article/details/81749385

 2. https://blog.csdn.net/u012162613/article/details/43221829

    经详细注释的代码：放在github地址上https://github.com/wepe/MachineLearning/tree/master/DeepLearning Tutorials/mlp