精华内容
下载资源
问答
  • 感知器学习

    2014-04-24 13:08:22
    掌握感知器学习算法 ① 初始化:将权值向量赋予随机值,t=0(迭代次数) ② 连接权的修正:对每个输入样本xk及期望输出dk完成如下计算 a. 计算网络输出:y = f(S),其中S =∑wixi,f为激活函数 b. 计算输出层单元期望...
  • 以下是本博客中关于感知器学习算法的主题:感知器作为线性分类器使用TensorFlow库实现感知器声纳数据分类使用单层感知器分类问题类型 可以对各种分类问题进行分类可以用神经网络分为两大类:基本上,如果你能用一条...
  • 感知器学习模型

    2017-02-21 18:19:14
    MATLAB 简单感知器学习模型
  • 感知器学习规则是: % Wnew = Wold + e*p % e = t - a % b = 粗体 + e %更新权重和偏差,直到得出正确的输入目标。 % 例如: % 和门: % P=[0 0 1 1; 0 1 0 1]; t=[0 0 0 1]; w=[0 0]; b=0; ep=20; % [wb]=...
  • 感知器学习对输入 x0,x1,x2 执行二进制 NAND 函数 阈值:0.5 偏差:0 学习率:0.1
  • 感知器学习笔记

    万次阅读 2016-06-09 21:11:19
    感知器学习笔记感知器(Perceptron) 是一种用于线性可分数据集的二类分类器算法。这种算法的局限性很大: 只能将数据分为 2 类 数据必须是线性可分的 虽然有这些局限,但是感知器是 ANN 和 SVM 的基础,理解了感知...

    感知器学习笔记

    感知器(Perceptron) 是一种用于线性可分数据集的二类分类器算法。这种算法的局限性很大:

    1. 只能将数据分为 2 类
    2. 数据必须是线性可分的

    虽然有这些局限,但是感知器是 ANN 和 SVM 的基础,理解了感知器的原理,对学习ANN 和 SVM 会有帮助,所以还是值得花些时间的。

    感知器可以表示为 f:RN{1,1} 的映射函数。其中 f 的形式如下:

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

    其中, w b 都是 N 维向量,是感知器的模型参数。感知器的训练过程其实就是求解w b 的过程。正确的 w b 所构成的超平面 w.x+b=0 恰好将两类数据点分割在这个平面的两侧。

    感知器的训练算法

    误分类的点 (xi,yi) ,则 xi 距离超平面的距离为:

    1||w|||wxi+b|

    ,其中 ||w|| w L2 范数。

    由于 |yi|=1 ,因此上式恰好等于

    yi(wxi+b)||w||

    定义损失函数为所有误分类数据点到超平面的距离之和。

    L0(w,b)=1||w||xiMyi(wxi+b)

    如果没有误分类点,则 L(w,b)=0 。感知器的训练算法就是求取使得 L(w,b)=0 w b

    大多数教科书上给出的感知机 sign(wx+b) 学习的损失函数定义为:

    L(w,b)=xiMyi(wxi+b)

    可以看到这个定义去掉了分母的 ||w|| 。当 ||w||0 时, L0(w,b)=0 L(w,b)=0 是等价的。而感知器的训练算法可以保证最终求得的 w 满足条件 ||w|| 。所以这样定义损失函数倒也没有问题。

    感知机学习算法

    1.感知机学习算法的原始形式:

    训练集:

    T={(x1,y1),(x2,y2),,(xN,yN)},xiRn,yi{+1,1}

    ,求参数 w,b ,使得
    minw,bL(w,b)=minw,bxiMyi(wxi+b)

    - 假设误分类点集合 M 是固定的,则损失函数 L(w,b) 的梯度由:
    wL(w,b)=xiMyixibL(w,b)=xiMyi

    这两个梯度给出的是损失函数增长的方向。后面使用时需用反方向。

    • 梯度下降法:随机选取一个误分类点 (xi,yi) ,对 w,b 进行更新:
      ww+η.yixibb+η.yi

      其中 η(0,1] 是学习率。通过迭代可以使得损失函数 L(w,b) 不断减小直到 0。

    可以证明,如果数据是线性可分的,那么这种算法是收敛的。也就是说经过有限步迭代,会求出能够正确分类的 w,b

    除了原始算法外,感知器还有所谓的对偶形式。这里就不多介绍了。需要进一步了解的可以参考李航写的《统计学习方法》一书。

    展开全文
  • 演示用于 2D 数据的非常简单的单层感知器学习
  • 感知器火花 spark中感知器学习算法的实现
  • 一个小小程序,感知器学习算法的神经学习!供参考而已
  • 机器学习之感知器学习算法

    千次阅读 2016-05-20 17:53:28
    Machine Learning---感知器学习算法 引言 这里开始介绍神经网络方面的知识(Neural Networks)。首先我们会介绍几个监督式学习的算法,随后便是非监督式的学习。 一、感知器学习算法基本介绍 1....

    Machine Learning---感知器学习算法

    引言

    这里开始介绍神经网络方面的知识(Neural Networks)。首先我们会介绍几个监督式学习的算法,随后便是非监督式的学习。

    一、感知器学习算法基本介绍


    1.神经网络

    就像进化计算,神经网络又是一个类似的概念。神经网络由一个或者多个神经元组成。而一个神经元包括输入、输出和“内部处理器”。神经元从输入端接受信息,通过“内部处理器”将这些信息进行一定的处理,最后通过输出端输出。

    2.感知器

    感知器(Perceptron),是神经网络中的一个概念,在1950s由Frank Rosenblatt第一次引入。

    3.单层感知器

    单层感知器(Single Layer Perceptron)是最简单的神经网络。它包含输入层和输出层,而输入层和输出层是直接相连的。


    图1.1

    图1.1便是一个单层感知器,很简单一个结构,输入层和输出层直接相连。

    接下来介绍一下如何计算输出端。


    利用公式1计算输出层,这个公式也是很好理解。首先计算输入层中,每一个输入端和其上的权值相乘,然后将这些乘机相加得到乘机和。对于这个乘机和做如下处理,如果乘机和大于临界值(一般是0),输入端就取1;如果小于临界值,就取-1。

    以下就给出一段单层感知器的代码。

    [cpp]  view plain  copy
     print ?
    1. //  
    2. //singlelayer perceptrons(SLP)  
    3. bool slp_calculate_output(constdouble * inputs,constdouble * weights,intnInputs,int & output)  
    4. {  
    5.     if(NULL ==inputs || NULL == weights)  
    6.         return false;  
    7.     double sum =0.0;  
    8.     for (int i = 0 ; i < nInputs ; ++i)  
    9.     {  
    10.         sum += (weights[i] * inputs[i]);  
    11.     }  
    12. //这里我们对乘机和的处理:如果大于0,则输出值为1;其他情况,输出值为-1  
    13.     if(sum >0.0)  
    14.         output = 1;  
    15.     else  
    16.         output = -1;  
    17. }  
    18. //  

    单层感知器其简单的特性,可以提供快速的计算。它能够实现逻辑计算中的NOT、OR、AND等简单计算。

    但是对于稍微复杂的异或就无能无力。下面介绍的多层感知器,就能解决这个问题。

    4.多层感知器

    多层感知器(Multi-Layer Perceptrons),包含多层计算。

    相对于单层感知器,输出端从一个变到了多个;输入端和输出端之间也不光只有一层,现在又两层:输出层和隐藏层。


    图2.2

    图2.2就是一个多层感知器。

    对于多层感知器的计算也是比较简单易懂的。首先利用公式1计算每一个。

    看一下它代码,就能明白它的工作原理。

    [cpp]  view plain  copy
     print ?
    1. //  
    2. //Multi-Layerperceptrons(MLP)  
    3. const unsignedint nInputs  =4;  
    4. const unsignedint nOutputs = 3;  
    5. const unsignedint nHiddens = 4;  
    6. struct mlp  
    7. {  
    8.     doubleinputs[nInputs+1];//多一个,存放的bias,一般存放入1  
    9.     doubleoutputs[nOutputs];  
    10.     doublehiddens[nHiddens+1]; //多一个,存放的bias,一般存放入1  
    11.     doubleweight_hiddens_2_inputs[nHiddens+1][nInputs+1];  
    12.     doubleweight_outputs_2_hiddens[nOutputs][nHiddens+1];  
    13. };  
    14. //这里我们对乘机和的处理:如果大于0,则输出值为1;其他情况,输出值为-1  
    15. double sigmoid (double val)  
    16. {  
    17.     if(val >0.0)  
    18.         return1.0;  
    19.     else  
    20.         return-1.0;  
    21. }  
    22. //计算输出端  
    23. bool mlp_calculate_outputs(mlp * pMlp)  
    24. {  
    25.     if(NULL ==pMlp)  
    26.         return false;  
    27.     double sum =0.0;  
    28.     //首先计算隐藏层中的每一个结点的值  
    29.     for (int h = 0 ; h < nHiddens ; ++h)  
    30.     {  
    31.         doublesum = 0.0;  
    32.         for (int i = 0 ; i < nInputs + 1 ; ++i)  
    33.         {  
    34.             sum += pMlp->weight_hiddens_2_inputs[h][i]*pMlp->inputs[i];  
    35.         }  
    36.        pMlp->hiddens[h] = sigmoid (sum);  
    37.    
    38.     }  
    39.      //利用隐藏层作为“输入层”,计算输出层  
    40.     for (int o = 0 ; o < nOutputs ; ++o)  
    41.     {  
    42.         doublesum = 0.0;  
    43.         for (int h = 0 ; h < nHiddens + 1 ; ++h)  
    44.         {  
    45.             sum += pMlp->weight_outputs_2_hiddens[o][h]*pMlp->hiddens[h];  
    46.         }  
    47.         pMlp->outputs[o] = sigmoid (sum);  
    48.     }  
    49.     return true;  
    50. }  
    51. //  


    二、感知器学习算法


    1.感知器学习

    其实感知器学习算法,就是利用第一节介绍的单层感知器。首先利用给的正确数据,计算得到输出值,将输出值和正确的值相比,由此来调整每一个输出端上的权值。


    公式2便是用来调整权值,首先 是一个“学习参数”,一般我将它设置成小于1的正数。T便是训练数据中的正确结果, 便是第i个输入端的输入值,便是第i个输入端上面的权值。

    2.代码

    对于其介绍,我还是附上代码。

    [cpp]  view plain  copy
     print ?
    1. //  
    2. //PerceptronLearning Algorithm(PLA)  
    3. const unsignedint nTests   =4; //训练数据的数量  
    4. const unsignedint nInputs  =2; //输入端的数量  
    5. const double alpha =0.2;       //学习参数  
    6. struct slp  
    7. {  
    8.     doubleinputs[nInputs];  
    9.     doubleoutput;  
    10. }; //单层感知器  
    11. //计算输出值  
    12. int compute(double *inputs,double * weights)  
    13. {  
    14.     double sum =0.0;  
    15.     for (int i = 0 ; i < nInputs; ++i)  
    16.     {  
    17.         sum += weights[i]*inputs[i];  
    18.     }  
    19.     //bias  
    20.     sum += 1.0 * weights[nInputs];  
    21.     if(sum >0.0)  
    22.         return1;  
    23.     else  
    24.         return-1;  
    25. }  
    26. //  
    27. int _tmain(int argc,_TCHAR* argv[])  
    28. {  
    29. //正确的训练数据  
    30.     slp slps[nTests] = {  
    31.         {-1.0,-1.0,-1.0},  
    32.         {-1.0, 1.0, 1.0},  
    33.         { 1.0,-1.0, 1.0},  
    34.         { 1.0, 1.0, 1.0}  
    35.     };  
    36.     doubleweights[nInputs + 1] = {0.0};  
    37.     boolbLearningOK = false;  
    38.   //感知器学习算法  
    39.     while(!bLearningOK)  
    40.     {  
    41.         bLearningOK = true;  
    42.         for (int i = 0 ; i < nTests ; ++i)  
    43.         {  
    44.             intoutput = compute(slps[i].inputs,weights);  
    45.             if(output!= (int)slps[i].output)  
    46.             {  
    47.                 for(int w = 0 ; w < nInputs ; ++w)  
    48.                 {  
    49.                     weights[w] += alpha *slps[i].output * slps[i].inputs[w];  
    50.                 }  
    51.                 weights[nInputs] += alpha *slps[i].output ;  
    52.                 bLearningOK = false;  
    53.             }  
    54.         }  
    55.     }  
    56.     for(int w = 0 ; w < nInputs + 1 ; ++w)  
    57.     {  
    58.         cout<<"weight"<<w<<":"<<weights[w] <<endl;  
    59.     }  
    60.     cout<<"\n";  
    61.     for (int i = 0 ;i < nTests ; ++i)  
    62.     {  
    63.         cout<<"rightresult:"<<slps[i].output<<"\t";  
    64.         cout<<"caculateresult:" << compute(slps[i].inputs,weights)<<endl;  
    65.     }  
    66.      
    67.     //  
    68.     char temp ;  
    69.     cin>>temp;  
    70.     return 0;  
    71. }  

    2.效果图

    下面附上运行效果图


    三、总结

    感知器学习算法,算是神经网络中的最简单的学习算法。但是通过这个进入学习神经网络学习算法,是个不错的选择。

    感知器学习算法,只要是利用了单层感知器。这篇文章中,我们还了解到了另一种感知器:多层感知器。多层感知器主要是用于方向传播学习算法中,这个我后面的文章中会进行介绍。

    由于笔者不是专门研究人工智能方面,所以在写这些文章的时候,肯定会有一些错误,也请谅解,上面介绍中有什么错误或者不当地方,敬请指出,不甚欢迎。

     

    如果有兴趣的可以留言,一起交流一下算法学习的心得。

    声明:本文章是笔者整理资料所得原创文章,如转载需注明出处,谢谢。

    展开全文
  • 感知器学习算法

    这一节我们简单地介绍历史上的著名算法——感知器算法,这在后面的学习理论中也会有所提及。设想我们改变逻辑回归算法,“迫使”它只能输出-1或1抑或其他定值。在这种情况下,之前的逻辑函数 g g g就会变成阈值函数 s i g n sign sign

    s i g n ( z ) = { 1 if  z ≥ 0 − 1 if  z < 0 sign(z) = \begin{cases} 1 & \quad \text{if}\ z \ge 0 \\ -1 & \quad \text{if}\ z \lt 0 \\ \end{cases} sign(z)={11if z0if z<0

    如果我们令假设为 h θ ( x ) = g ( θ T x ) h_\theta(x) = g(\theta^T x) hθ(x)=g(θTx),将其带入之前的迭代法中:

    θ j : = θ j + α ( y ( i ) − h θ ( x ( i ) ) ) x j ( i ) . \theta_j := \theta_j + \alpha(y^{(i)} - h_\theta(x^{(i)}))x^{(i)}_j. θj:=θj+α(y(i)hθ(x(i)))xj(i).

    至此我们就得出了感知器学习算法。在19世纪60年代,感知器被认为是大脑中神经元工作的初步模型。需要注意的是虽然感知器模型和我们之前的算法形式上很相似,但它实际上和线性回归等算法是完全不同类型的算法。尤其你很难像线性回归一样给感知器概率论上的有效阐述或极大似然估计的推导。

    感知器模型的另一种阐述

    数据集的线性可分性

    给定一个数据集
    T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1,y1),(x2,y2),...,(xN,yN)}
    其中, x i ∈ X ∈ R n , y i ∈ Y = { + 1 , − 1 } , i = 1 , 2 , . . . , N x_i\in\mathcal{X}\in R^n,\quad y_i\in\mathcal{Y}=\{+1,-1\},\quad i=1,2,...,N xiXRn,yiY={+1,1},i=1,2,...,N,如果存在某个超平面S
    w ⋅ x + b = 0 w\cdot x + b =0 wx+b=0
    能够将数据集的正实例点和负实例点完全正确地划分到超平面的两侧,则称数据集T为线性可分数据集。

    感知机学习策略

    假设数据集是线性可分的,感知机学习的目标是求得一个能够将训练集正负实例点完全分开的超平面。为了找出这样的超平面,即确定感知机的模型参数 w 、 b w、b wb,需要定义一个损失函数(成本函数)并将损失函数极小化。

    损失函数的一个自然选择是误分类点的个数。但这样的损失函数不是参数 w 、 b w、b wb的连续可到函数,不易优化。损失函数的另一个选择是误分类点到超平面的距离,这时感知机所采用的。
    首先写出空间 R n R^n Rn中任一点 x 0 x_0 x0到超平面S的距离:
    1 ∥ w ∥ ∣ w ⋅ x 0 + b ∣ \frac{1}{\Vert w \Vert}\vert w \cdot x_0 + b \vert w1wx0+b
    这里 ∥ w ∥ \Vert w \Vert w w w w L 2 L_2 L2范数。对于误分类点则有:
    − y i ( w ⋅ x i + b ) > 0 -y_i(w \cdot x_i + b) \gt 0 yi(wxi+b)>0
    所以误分类点到超平面的距离是
    − 1 ∥ w ∥ y i ( w ⋅ x i + b ) -\frac{1}{\Vert w\Vert}y_i(w \cdot x_i + b) w1yi(wxi+b)
    那么所有误分类点到超平面的距离为
    − 1 ∥ w ∥ ∑ x i ∈ M y i ( w ⋅ x i + b ) -\frac{1}{\Vert w\Vert}\sum_{x_i \in M} y_i(w \cdot x_i + b) w1xiMyi(wxi+b)
    不考虑 1 ∥ w ∥ \frac{1}{\Vert w\Vert} w1,就得到感知机学习的损失函数。感知机 s i g n ( w ⋅ x + b ) sign(w \cdot x + b) sign(wx+b)学习的损失函数定义为

    L ( w , b ) = − ∑ x i ∈ M y i ( w ⋅ x i + b ) L(w,b)=-\sum_{x_i \in M} y_i(w \cdot x_i + b) L(w,b)=xiMyi(wxi+b)

    使用随机梯度下降法优化模型,则有:

    ∇ w L ( w , b ) = − ∑ x i ∈ M y i x i ∇ b L ( w , b ) = − ∑ x i ∈ M y i \begin{aligned} \nabla_w L(w,b) & = -\sum_{x_i \in M} y_i x_i \\ \nabla_b L(w,b) & = -\sum_{x_i \in M} y_i \end{aligned} wL(w,b)bL(w,b)=xiMyixi=xiMyi

    每碰到一个误分类点 ( x i , y i ) (x_i, y_i) (xi,yi),对 w , b w,b w,b进行更新:

    w : = w + η y i x i b : = b + η y i \begin{aligned} w &:= w + \eta y_i x_i \\ b & := b + \eta y_i \end{aligned} wb:=w+ηyixi:=b+ηyi

    本文主要内容来自吴恩达老师网易公开课机器学习中的课件,本人自行翻译并重新对文章进行编辑排版,转载请注明出处

    展开全文
  • 机器学习-感知器学习算法

    千次阅读 2017-06-22 22:13:49
    机器学习-感知器学习算法    Python语言实现

    由于文章编辑问题,图片和公式都无法展示,需要原文章和源代码的,请下载
    链接: http://pan.baidu.com/s/1dE8yK1N 密码: 2c9n

    机器学习-感知器学习算法

                                                                                                                            Python语言实现

                                                                                       初学者整理,参考资料均来源于网上

    一、           概述

    感知器是由美国计算机科学家罗森布拉特(Rosenblatt)于1957年提出的。感知器可谓是最早的人工神经网络。

         感知器分单层感知器和多层感知器。

    二、           单层感知器(Single Layer Perceptron

    l 简介

    单层感知器是一个具有一层神经元、采用阈值激活函数的前向网络。通过对网络权值的训练,可以使感知器对一组输人矢量的响应达到元素为01的目标输出,从而实现对输人矢量分类的目的。

    单层感知器是一个简单的线性二分类器,它保存着输入权重,根据输入和内置的函数计算输出.人工神经网络中的单个神经元。

    单层感知器可以计算逻辑或,逻辑与,逻辑非等运算,但是不能计算异或。因为异或不是平面线性可分的,在多层感知器中解决。

    l 模型

    单层感知器只有输入和输出,输入和输出直接相连,多个输入一个输出。

    模型为每个输入定义为X,输入到输出的权重定义为w,所有的输入和权重的乘积和为输出的值,对于这个乘积和做如下处理,如果乘机和大于临界值(一般是0),输入端就取1;如果小于临界值,就取-1

    l 工作原理

    单层感知器可将外部输入分为两类。当感知器的输出为+1时,输入属于L1,当感知器输出-1时,输入属于L2类,从而实现两类目标的识别。在二维空间,单层感知器进行模式识别的判决超平面由下式决定:

    对于只有两个输入的判别边界是直线(),选择合适的学习算法可训练出满意的w1w2。将样本中两类数据用直线分开。如下图:

    b的值决定了直线的偏移量,w决定了直线的旋转度数。

    l 学习算法

    第一步、设置变量和参数

    f(x)为激活函数,y(n)为实际输出,d(n)为期望输出,λ为学习速率,n为迭代次数,e为实际输出与期望输出的误差。

    第二步、初始化

    给权值向量w的各个分量赋一个较小的随机非零值,置n=1

    第三步、输入一组样本X(n)=[1,x1(n),x2(n),…,xm(n)],并给出它的期望输出d(n)

    第四步、计算出实际输出:y(n)=f()

    第五步、求出期望输出和实际输出的差 e=d(n)-y(n)。根据误差判断输出是否满足条件,一般为对所有样本误差为零或者均小于预设的值,则算法结束,否则将值增加1,并用下式调整权值:

    w(n+1)=w(n)+λ[d(n)-y(n)]x(n)

    权值调整公式属于随机梯度下降算法。(待确认)

    然后转到第三步,进行下一轮计算过程。

    l 代码(Python)

    感知器源码(Perceptron.py)

    #单层感知器机器学习算法 20170621 gyk

     

    #多层感知器使用梯度下降算法进行训练

    #单层感知器只能解决线性可分问题

     

    #importlogging

    #importos

     

    #预测函数,训练使用使用公式“输入×权重的和”为结果。使用阶跃函数sigmoid把结果转换为10

    #由于默认第一个输入为1,第一个权重为b,所以在公式转换为:w1*x1+w2*x2+b=0

    #结果等于0为线性分割线的线上。小于0为线下,大于0为线上。用该线把结果分成两种。

    #由于在预测的时候,输入参数比训练参数少一个结果列,所以不能用输入参数数组计算特征列,而是用权重数组减去第一个bias偏移量列来计算特征数。

    defpredict(inputs, weights):

       activation = weights[0]

       for i in range(len(weights)-1):

           activation += weights[i+1]*inputs[i]

       return sigmoid(activation)

     

    #阶跃函数,把值转换成1/0或者1/-1

    defsigmoid(value):

       return 1.0 if value >= 0.0 else 0.0

     

    #训练

    #初始化权重为0.5,然后循环训练集,读取每一条训练集数据,进行预测,然后把预测结果和实际结果进行对比,如果一样就用下一条训练。如果和实际结果不相等。就使用随机梯度下降算法重新计算权重。

    #然后重新训练,直到所有训练数据的预测结果和实际结果一直,则训练结束。

    #训练的结果其实就是在平面上找一条直线,该直线能把两类的数据点分割在直线的两边。如果有的点是错误的,就变化w1w2来旋转直线,变化w0来移动直线找到最佳位置。训练速率太大会找不到最佳位置,

    #训练速率太小,训练速度就太慢。期望值和实际值的差值的正负决定了旋转和移动的方向。

    #l_rate为学习速率,一般在00.1之间取值。

    def train(dataSet,l_rate):

       count = 0

       weights = [0.5 for i inrange(len(dataSet[0]))]

       learningOK = False

       while not learningOK:

           if count >= 100:

               print('训练已经超过100次,无法完成训练')

               return None

           else:   

               count += 1

               

           learningOK = True

           for input_row in dataSet:

               prediction = predict(input_row,weights)

               error = input_row[-1] - prediction#期望输出与实际输出误差

               if error != 0:

                   weights = sgd(weights,input_row, l_rate, error)

                   learningOK = False          

       return weights

     

    #随机梯度下降算法,计算新的权重,即改变分割线的位置

    defsgd(weights, input_row, l_rate, error):

       for i in range(len(input_row)-1):

           weights[i+1] += l_rate * error*input_row[i]                       

       weights[0] += l_rate * error

       return weights

       

    测试源码(Perceptron_UnitTest.py)

    #单层感知器单元测试 20170621 gyk

     

    from impimport reload

    fromPerceptron import *

     

    #测试

    deftest():

       l_rate = 0.2 #学习速率

       l_while = True

       dict_function ={'or':test_or,'and':test_and,'not':test_not,'xor':test_xor}

     

       while l_while:

           print('输入q退出,输入or实现或功能,输入not实现非功能,输入and实现与功能。输入xor调用异或功能。或直接用命令行调用test_others函数可以实现其他预测')

           type_str = input()

           if type_str == 'q':

               l_while = False

           else:

               dict_function.get(type_str,'nothing')(l_rate)             

     

    #计算或使用或数据集训练完模型,实现或的效果。

    deftest_or(l_rate):

           weights =train([[1,1,1],[1,0,1],[0,1,1],[0,0,0]] , l_rate)

           test_common([int(input('第一个参数')),int(input('第二个参数'))], weights)

     

    #计算与使用或数据集训练完模型,实现或的效果。

    deftest_and(l_rate):

           weights =train([[1,1,1],[1,0,0],[0,1,0],[0,0,0]] , l_rate)

           test_common([int(input('第一个参数')),int(input('第二个参数'))],weights)

     

    #计算异或使用异或数据集训练完模型,实现异或的效果。单层感知器无法完成异或功能。

    deftest_xor(l_rate):

           print('单层感知器无法完成异或功能')

           weights =train([[1,1,0],[1,0,1],[0,1,1],[0,0,0]] , l_rate)

           if weights != None:

               test_common([int(input('第一个参数')),int(input('第二个参数'))],weights)       

     

    #计算非使用或数据集训练完模型,实现或的效果。

    deftest_not(l_rate):

           weights = train([[0,1],[1,0]] , l_rate)

           test_common([int(input('第一个参数'))], weights)

     

    #计算通用

    deftest_common(inputs, weights):

       if weights != None:

           print('结果为:%d'%predict1(inputs, weights))

     

    #训练其他功能,只要输入训练集和待预测数据,就能预测出结果

    deftest_others(trainDataSet, inputs):

           weights = train(trainDataSet , 0.2)

           test_common(inputs, weights)       

           

    if__name__=='__main__':

       #logging.basicConfig(filename =os.path.join(os.getcwd(), 'log.txt'), level = logging.DEBUG)

       test() 

    三、           多层感知器(Multi-Layer Perceptrons

    l 简介

    多层感知机(Multi Layer Perceptron MLP)是由多个感知机层全连接组成的前馈神经网络,这种模型在非线性问题中表现出色.

    相对于单层感知器,输出端从一个变到了多个;输入端和输出端之间也不光只有一层,增加了隐藏层。

    所谓全连接是指层A上任一神经元与临近层B上的任意神经元之间都存在连接.

    反向传播(Back PropagationBP)是误差反向传播的简称,这是一种用来训练人工神经网络的常见算法,通常与最优化方法(如梯度下降法)结合使用.多层感知器就是使用BP算法进行训练的。

    l 模型

    l 工作原理

    由前面介绍看到,单个感知器能够完成线性可分数据的分类问题,是一种最简单的可以学习的机器。但他无法解决非线性问题。比如下图中的XOR问题:即(1,1)(-1,-1)属于同一类,而(1,-1)(-1,1)属于第二类的问题,不能由单个感知器正确分类。

    https://img-blog.csdn.net/20130601150444390

    单个感知器虽然无法解决异或问题,但却可以通过将多个感知器组合,实现复杂空间的分割。如下图:

    https://img-blog.csdn.net/20130601150455577

    将两层感知器按照一定的结构和系数进行组合,第一层感知器实现两个线性分类器,把特征空间分割,而在这两个感知器的输出之上再加一层感知器,就可以实现异或运算。

    也就是,由多个感知器组合:

    https://img-blog.csdn.net/20130601151729163

    来实现非线性分类面,其中θ(·)表示阶跃函数或符号函数。

    l 学习算法

    经典的BP神经网络通常由三层组成:输入层,隐含层与输出层.通常输入层神经元的个数与特征数相关,输出层的个数与类别数相同,隐含层的层数与神经元数均可以自定义

    http://images2015.cnblogs.com/blog/793413/201610/793413-20161010152810539-341221931.png

    每个隐含层和输出层神经元输出与输入的函数关系为:

    I j =∑ i W ij O i  Ij=∑iWijOi

    O j =sigmod(I l )=11+e −I l    Oj=sigmod(Il)=11+e−Il

    其中W ij  Wij表示神经元i与神经元j之间连接的权重,O j  Oj代表神经元j的输出, sigmod是一个特殊的函数用于将任意实数映射到(01)区间.

    上文中的sigmod函数称为神经元的激励函数(activation function)除了sigmod函数11+e −I l    11+e−Il外,常用还有tanhReLU函数.

    我们用一个完成训练的神经网络处理回归问题,每个样本拥有n个输入.相应地,神经网络拥有n个输入神经元和1个输出神经元.

    实际应用中我们通常在输入层额外增加一个偏置神经元,提供一个可控的输入修正;或者为每个隐含层神经元设置一个偏置参数.

    我们将n个特征依次送入输入神经元,隐含层神经元获得输入层的输出并计算自己输出值,输出层的神经元根据隐含层输出计算出回归值.

    上述过程一般称为前馈(Feed-Forward)过程,该过程中神经网络的输入输出与多维函数无异.

    现在我们的问题是如何训练这个神经网络.

    作为监督学习算法,BP神经网络的训练过程即是根据前馈得到的预测值和参考值比较,根据误差调整连接权重W ij  Wij的过程.

    训练过程称为反向传播过程(BackPropagation)数据流正好与前馈过程相反.

    首先我们随机初始化连接权重W ij  Wij对某一训练样本进行一次前馈过程得到各神经元的输出.

    首先计算输出层的误差:

    E j =sigmod ′ (O j )∗(T j −O j )=O j (1−O j )(T j −O j ) Ej=sigmod′(Oj)∗(Tj−Oj)=Oj(1−Oj)(Tj−Oj)

    其中E j  Ej代表神经元j的误差,O j  Oj表示神经元j的输出,T j  Tj表示当前训练样本的参考输出,sigmod ′ (x) sigmod′(x)是上文sigmod函数的一阶导数.

    计算隐含层误差:

    E j =sigmod ′ (O j )∗∑ k E k W jk =O j (1−O j )∑ k E k W jk  Ej=sigmod′(Oj)∗∑kEkWjk=Oj(1−Oj)∑kEkWjk

    隐含层输出不存在参考值,使用下一层误差的加权和代替(T j −O j ) (Tj−Oj) .

    计算完误差后就可以更新W ij  Wijθ j  θj :

    W ij =W ij +λE j O i  Wij=Wij+λEjOi

    其中λ λ是一个称为学习率的参数,一般在(00.1)区间上取值.

    实际上为了加快学习的效率我们引入称为矫正矩阵的机制,矫正矩阵记录上一次反向传播过程中的E j O i  EjOi值,这样W j  Wj更新公式变为:

    W ij =W ij +λE j O i +μC ij  Wij=Wij+λEjOi+μCij

    μ μ是一个称为矫正率的参数.随后更新矫正矩阵:

    C ij =E j O i  Cij=EjOi

    每一个训练样本都会更新一次整个网络的参数.我们需要额外设置训练终止的条件.

    最简单的训练终止条件为设置最大迭代次数,如将数据集迭代1000次后终止训练.

    单纯的设置最大迭代次数不能保证训练结果的精确度,更好的办法是使用损失函数(loss function)作为终止训练的依据.

    损失函数可以选用输出层各节点的方差:

    L=∑ j (T j −O j ) 2  L=∑j(Tj−Oj)2

    为了避免神经网络进行无意义的迭代,我们通常在训练数据集中抽出一部分用作校验.当预测误差高于阈值时提前终止训练.

     

    l 代码

    多层感知器源码(MLP.py):

    #多层感知器机器学习算法 20170621 gyk

     

    #多层感知器使用BP算法进行训练

     

    #多层感知器,可以实现平面无法完成线性分割。把点看成是在立体空间中,用平面对他们进行分割

    #隐藏节点数量的计算公式:s=[2*log2(m+n+1)]>=2 s为隐藏节点数,m为输入特征数,n为识别出的类别数

     

    import logging

    import random

    import math

     

    class Mlp(object):

       

       #构造器 learn学习速率 limit最大循环次数 correct矫正率   

       def __init__(self, learn=0.05, limit=10000,correct=0.1):

           random.seed(0)

           self.__learn = learn

           self.__limit = limit

           self.__correct = correct

     

           self.__input_count = 0

           self.__hidden_count = 0

           self.__output_count = 0

     

           self.__inputs = []

           self.__hiddens = []

           self.__outputs = []

           self.__input_weights = []

           self.__output_weights = []

           self.__input_correction = []

           self.__output_correction = []     

           

       #初始化 input_count输入节点数量 hidden_count隐藏节点数量 output_count输出节点数量

       #输入节点数量和特征数量相关输出节点数量和输出类别数量相关

       def init(self, input_count, hidden_count,output_count):

           #初始化输入,隐藏,输出数量

           self.__input_count = input_count + 1

           self.__hidden_count = hidden_count

           self.__output_count = output_count

     

           #初始化输入,隐藏,输出节点的值

           self.__inputs = [1.0] *self.__input_count

           self.__hiddens = [1.0] *self.__hidden_count

           self.__outputs = [1.0] *self.__output_count

     

           #初始化存放一级,二级权重数组给权重赋值随机数一级权重多加一列保存偏移量

           self.__input_weights =[[self.rand(-0.2, 0.2) for i in range(self.__hidden_count)]for j in range(self.__input_count)]

           self.__output_weights =[[self.rand(-2.0, 2.0) for i in range(self.__output_count)]for j inrange(self.__hidden_count)]

     

           #初始化纠正数组一级权重多加一列保存偏移量

           self.__input_correction =self.make_matrix(self.__input_count, self.__hidden_count)

           self.__output_correction =self.make_matrix(self.__hidden_count, self.__output_count)

           

       #构造二维数组   

       def make_matrix(self, row_count,column_count, value=0.0):

           mat = []

           for i in range(row_count):

               mat.append([value] * column_count)

           return mat

     

       #生成随机数

       def rand(self, a, b):

           return (b - a) * random.random() + a

     

       #阶跃函数

       def sigmoid(self, x):

           return 1.0 / (1.0 + math.exp(-x))

     

                       

       #阶跃函数导数

       def sigmoid_derivate(self, x):

           return x * (1 - x)

     

       #训练

       def train(self, trainDataSet, labels):

           leaningOK = False

           for i in range(self.__limit):

               if leaningOK: #无损失,退出,训练完成

                   return None

               

               error = 0.0

               for j in range(len(trainDataSet)):

                   self.predict(trainDataSet[j])

                   error +=self.back_propagate(labels[j])

               logging.debug("当前循环次数为:%d当前损失函数错误值为:%f"%(i,error))

               leaningOK = error <= 0.01

     

       #预测

       def predict(self, inputDataSet):

           #计算输入层

           for i in range(self.__input_count-1):

               self.__inputs[i] = inputDataSet[i]

     

           #计算隐藏层

           for h in range(self.__hidden_count):

               total = 0.0        

               for i inrange(self.__input_count):               

                   total += self.__inputs[i] *self.__input_weights[i][h]

               self.__hiddens[h] =self.sigmoid(total)

     

           #计算输出层

           for o in range(self.__output_count):

               total = 0.0

               for h inrange(self.__hidden_count):

                   total += self.__hiddens[h] *self.__output_weights[h][o]

               self.__outputs[o] =self.sigmoid(total)

     

           return self.__outputs[:]

     

       #反向传播更新权值

       def back_propagate(self, labels):

           #计算输出层误差

           output_deltas = [0.0] *self.__output_count

           for o in range(self.__output_count):

               error = labels[o] -self.__outputs[o]

               output_deltas[o] =self.sigmoid_derivate(self.__outputs[o]) * error

     

           #计算隐藏层误差

           hidden_deltas = [0.0] *self.__hidden_count

           for h in range(self.__hidden_count):

               error = 0.0

               for o inrange(self.__output_count):             

                   error += output_deltas[o] *self.__output_weights[h][o]               

               hidden_deltas[h] =self.sigmoid_derivate(self.__hiddens[h]) * error

     

           #更新输出对应的权值

           for h in range(self.__hidden_count):

               for o inrange(self.__output_count):

                   change = output_deltas[o] *self.__hiddens[h]

                   self.__output_weights[h][o] +=self.__learn * change + self.__correct * self.__output_correction[h][o]

                   self.__output_correction[h][o]= change

     

           #更新输入对应的权值

           for i inrange(self.__input_count):       

               for h inrange(self.__hidden_count):

                   change = hidden_deltas[h] *self.__inputs[i]

                   self.__input_weights[i][h] +=self.__learn * change + self.__correct * self.__input_correction[i][h]

                   self.__input_correction[i][h] =change

     

           #返回错误总量

           error = 0.0

           for o in range(self.__output_count):

               error += 0.5 * (labels[o] -self.__outputs[o]) ** 2

           return error

          

    测试源码(MLP_UnitTest.py):

    #多层感知器单元测试 20170621gyk

     

    from imp import reload

    from MLP import *

    import logging

    import os

     

    #测试

    def test():

       l_while = True

       dict_function = {'or':test_or,'xor':test_xor}

     

       whilel_while:

           print('输入q退出,输入or实现或功能,输入xor调用异或功能。或直接用命令行调用test_others函数可以实现其他预测')

           type_str = input()

           if type_str == 'q':

               l_while = False

           else:

               dict_function.get(type_str,'nothing')()             

     

    #计算或使用或数据集训练完模型,实现或的效果。

    def test_or():

           test_common([[1,1],[1,0],[0,1],[0,0]], [[1],[1],[1],[0]], [int(input('第一个参数')),int(input('第二个参数'))])

     

     

    #计算异或使用异或数据集训练完模型,实现异或的效果。

    def test_xor():

           test_common([[1,1],[1,0],[0,1],[0,0]], [[0],[1],[1],[0]], [int(input('第一个参数')),int(input('第二个参数'))])       

     

    #计算通用

    def test_common(trainDataSet, labels,inputs):

       mlp = Mlp()

       mlp.init(2,5,1) #隐藏节点数量的计算公式:s=[2*log2(m+n+1)]>=2 s为隐藏节点数,m为输入特征数,n为识别出的类别数

       mlp.train(trainDataSet, labels)

       print('结果为:')

       for i in range(1):

           #print(mlp.predict(inputs)[i])

           print(1 if mlp.predict(inputs)[i]>=0.5 else 0)

     

    #训练其他功能,只要输入训练集和待预测数据,就能预测出结果

    def test_others(trainDataSet, inputs):

           test_common(trainDataSet, inputs)       

           

    if __name__=='__main__':

       #logging.basicConfig(filename = os.path.join(os.getcwd(), 'log.txt'),level = logging.DEBUG)

       test() 

     

     

     

     

     

    
    
    展开全文
  • 利用Python实现一个感知器学习算法

    千次阅读 2018-10-20 23:39:46
    Frank Rossenblatt 基于MCP神经元模型提出了第一个感知器学习法则,在此感知器规则中,他提出了一个自学算法,此算法可以自动通过优化得到权重系数,此系数与输入值的乘积决定了神经元是否被激活。MFC神经元和...
  • 目前我们接触到的感知器学习规则,数学建模之后,我们知道如何调整权值,使得感知器的切分符合我们的预期输入,下面我们就用一个小推导,看看感知器是如何进行权值调整的: 理论 判定边界 判定边界由那些使得净...
  • Machine Learning---感知器学习算法

    万次阅读 多人点赞 2013-02-02 16:40:14
    Machine Learning---感知器学习算法 引言 这里开始介绍神经网络方面的知识(Neural Networks)。首先我们会介绍几个监督式学习的算法,随后便是非监督式的学习。 一、感知器学习算法基本介绍 1.神经网络 就...
  • Machine Learning-感知器学习算法

    千次阅读 2016-01-06 16:08:00
    一、感知器学习算法基本介绍 1.神经网络 就像进化计算,神经网络又是一个类似的概念。神经网络由一个或者多个神经元组成。而一个神经元包括输入、输出和“内部处理器”。神经元从输入端接受信息,通过“内部处理器...
  • 当与具有期望输出的网络输出进行比较时,如果存在误差,则在时刻 k 与第 i 个处理单元相关联的权重向量 w(k) 被校正(调整)为w... 感知器学习规则由下式给出: w(k+1) = w(k) + eta*[ y(k) - sgn(w'(k)*x(k)) ]*x(k)
  • 什么是感知器学习算法(Perceptron Learning Algorithm/PLA)?
  • 倾心推荐,模式识别 感知器学习算法 Widrow-Hoff算法 GUI界面程序 Java代码,可以自己选择样本的坐标(使用者首先在坐标面板上按类别标注点,当单选按钮选择类1时,表示此时标注的属于类1,单选按钮选择类2表示新...
  • 感知器学习算法(PLA)及python实现

    千次阅读 2018-06-24 16:56:20
    感知器学习算法(PLA) 1、感知器原理 感知器是最简单的人工神经网络结构之一,由 Frank Rosenblatt 发明于 1957。它是基于一种稍微不同的人工神经元,称为线性阈值单元(LTU):输入和输出现在是数字(而不是二...
  • matlab实现感知器学习算法

    千次阅读 2014-03-08 22:37:47
    1958年,美国学者F.Rosenblatt提出了适于简单模式分类的感知器学习算法。 其中x1,x2,...,xn表示外界对于第k个神经元的刺激,在具体的科学实践中表示信号或图像的像素点值。wk1,wk2,...wkn分别表示n个输入对神经元...
  • 该课程第二讲是简单的感知器学习算法(PLA,即perceptron learning algorithm),主要处理线性可分的二分类问题。 二分类问题可描述为:现有N个训练样本 ,每个样本的输出 ,可用简单的符号函数来描述该过程,即,而...
  • 人工神经网络应用广泛,其中感知器是最简单的一种,包括单层神经网络和多层神经网络
  • 感知器模型 这是简单感知器模型的代码。 感知器由康奈尔航空实验室的Frank Rosenblatt于1957年发明,感知器是可能的最简单的神经网络:单个神经元的计算模型。 感知器由一个或多个输入,一个处理器和一个输出组成。...
  • 以下为训练过程,其中nn是单层感知器,Train为它的训练函数,其他感知器类似。 这例子为!x的感知器的训练: int time=11111; // 训练的循环数 for(int i=0;i;++i)// 训练 { for(int j=0;j;++j) { nn.x...
  • C++实现感知器学习作业1

    千次阅读 2014-11-30 12:57:52
    </pre><pre name="code" class="cpp"></pre><pre ...通过C++编程实现感知器学习,我对其的原理理解更深刻了,只有通过一次次修改代码和查阅资料才知道自己对算法的些地方存在错误的认识,再不断改进自己的算法。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,940
精华内容 33,576
关键字:

感知器学习