精华内容
下载资源
问答
  • 单层感知器线性分类
    2022-05-21 20:55:13

    感知器是一种比较简单的,通过训练样本集合来获取W向量的分类器。在获取W向量之后,可以输入检验集合来将检验集合的每个样本分为两类。

    MATLAB编程思路:

    (1)设计感知器

    创建感知器函数。函数有三个参数,分别是第一类样本集w1,第二类样本集w1以及感知器内部寻找W向量的最大循环次数K。

    基于感知器的原理,我们要将原本是二维的向量扩充到三维,即在每个样本的最后一位加一个“1”。

    进行标准化。将w1类的样本不变,将w2类的样本取负。将w1和w2合并,作为最终的样本训练集。

    进行循环。初始化W向量,W的维度和每个样本维度保持一致。判别每个样本集,如果W的转置乘以当前样本的值小于等于0,那么将W进行更新,W原值加上当前样本的c倍作为新的W的值。c值可以自己设置。直到循环结束或者找到满足所有样本集合的W向量。

    (2)对验证集合分类

    随机创建n个验证集合,每个样本均为二维纵向量。将每个样本扩充到三维。之后,进行循环,对每个样本,用上面求得的W向量的转置乘以当前样本,如果值大于0 ,则此样本归为第一类,否则就归为第二类。最终,用散点图的形式呈现出来。

    代码下载:https://download.csdn.net/download/k1ttyLove/85432566icon-default.png?t=M4ADhttps://download.csdn.net/download/k1ttyLove/85432566

     

    更多相关内容
  • 单层感知器线性分类、多层感知器非线性分类样例 调用matlab神经网络工具箱实现
    %给定样本输入向量P,目标输出向量T
    %net = newp(PR,S,TF,LF)
    %PR为输入矢量的取值范围的最大值和最小值 S为神经元的个数 TF为网络的传递函数 默认为hardlim LF为网络的学习函数 默认为learnp
    %以及需要分类的向量组Q
    %设计一个单层感知机对其分类
    %[net,tr,Y,E,Pf,Af] = train(net,P,Pi,Ai)
    %train通过调用网络训练函数net.trainFcn并根据训练函数net.trainParam对网络进行训练
    %在输入变量中net为神经网络对象 P为网络输入 T为目标矢量Pi为输入延迟的初始状态 Ai为层延迟的初始状态
    %在返回函数中net为新的网络 tr为训练记录 Y为网络输出 E为输出和目标矢量之间的误差 Pf为训练终止时输入的延时状态
    %Af为训练终止时的层延时状态
    P = [-0.3 -0.8 0.4;0.6 0 0.1];
    T = [1 1 0];
    net = newp([-1 1;-1 1],1);  %设置单层感知器 
    net.trainParam.epochs = 10; %设置网络的最大训练次数为20
    net = train(net,P,T);       %使用训练函数对创建的网络进行训练
    Y = sim(net,P);             %对训练后的网络进行仿真
    E1 = mae(Y-T);              %计算输出量与目标量之间的均方误差
    Q = [0.6 0.9 -0.1;-0.1 -0.5 0.5]; %检测训练好的神经网络的性能
    Y1 = sim(net,Q);            %对网络进行仿真,仿真输出即为分类的结果
    figure;                     %创建一个绘图的窗口
    plotpv(Q,Y1);               %绘制输入向量和目标向量plotpv(P,T,V)输入向量、目标向量、控制图形的最大范围
    plotpc(net.iw{1},net.b{1}); %在感知器向量图中绘制分界线plotpc(W,B,H)加权矩阵、阈值向量、最后画线的控制权
    
    

    分类结果:

     对于线性不可分的例子,如下图的两类模式(类a表示垂直线 类b表示平行线)通过感知器网络分类。显然对于两类模式类别无法用一个超平面分开,所以单层感知器是无法完成此任务。这里设置一个多层感知器网络来解决此问题。

    多层感知器的结构如下,其中对应的传递函数f为强限幅传递函数:

     

    对应强限幅传递函数公式如下:

    \operatorname{hardlim}(x)= \begin{cases}1 & x \geqslant 0 \\ 0 & x<0\end{cases}

    通过依次扫描模式中的各列,将模式表示成向量。白方块用”-1“ 表示,黑方块用”1“表示,对于样本希望分两类即垂直的为1 水平的为0,则输入样本用p1 p2 p3 p4 表示,如下表:

    输入样本目标向量
    p11 1 -1 -11
    p2-1 -1 1 1 1
    p31  -1 1 -10
    p4-1 1 -1 10

    将输入向量的前两个输入输入第一层感知器的第一个神经元,将输入向量的后两个输入输入第一层感知器的第二个神经元,运算结果如下图所示,其中p1、p11分别为两个神经元的输入,b1、b11分别为两个神经元的偏置(随机得到),iw1、iw11分别为两个神经元的[1行2列]权值矩阵(随机的到)a1、a11分别为两个神经元的输出。

    第一次输入具体计算公式如下:

     将第一层神经元输出组合后组成[2*4]的矩阵输入第二层神经元,在第二层神经元训练仿真后若输入的向量满足目标向量则训练结束。训练完成后得到的net可对输入向量进行分类。

    在命令行输入

    sim(net2,p2)

    得到结果:

    满足最初目标垂直线样本标记为1 水平线标记为0 。

    上述非线性可分样例的代码如下:

    pr1 = [-1 1;-1 1];%随机感知器     输入的范围
    net1 = newp(pr1,1);
    net11 = newp(pr1,1);
    %%
    %随机权重、偏置参数
    net1.inputweights{1}.initFcn = 'rands';
    net1.biases{1}.initFcn = 'rands';
    net11.inputweights{1}.initFcn = 'rands';
    net11.biases{1}.initFcn = 'rands';
    index = 0;
    while index == 0
     %%
     %第一层
     %神经元1
        net1 = init(net1);
        %iw1[1 2] * p1[2 4] = a1[1 4];
        %表示输入层到第一层隐层的权重
        iw1 = net1.IW{1};%net.IW{i,j}表示从第j个输出到第i层权重的权重矩阵,其值为N*R的矩阵
        b1 = net1.b{1};  %表示第一层隐层的偏置,其值为N*1的矩阵
        p1 = [1 -1 1 -1;1 -1 -1 1]; %第一层第一个单层感知器的输入
        [a1] = sim(net1,p1);        %进行仿真,输出结果到a1
    %神经元2
        %iw11[1 2] * p11[2 4] = a11[1 4];
        net11 = init(net11);
        iw11 = net11.IW{1};
        b11 = net11.b{1};
        p11 = [-1,1,1,-1;-1,1,-1,1];%第一层第二个单层感知器的输入
        [a11] = sim(net11,p11);     %进行仿真,输出结果到a11
        
    %%
    %第二层
        pr2 = [0 1;0 1];
        net2 = newp(pr2,1);         %第二层单个感知器建立,一个神经元
        net2.trainParam.epochs = 10;%最大训练次数(步数)设置为10
        net2.trainParam.show = 1;   %每隔一次展示一下训练结果
        p21 = ones(size(a1));
        p21 = p21.*a1;
        p22 = ones(size(a11));
        p22 = p22.*a11;
        p2 = [p21;p22];             %第一层中两个单层感知器的输出作为第二层单层感知器的输入
        t2 = [1 1 0 0];             %目标向量
        [net2,tr2] = train(net2,p2,t2);%第二层单层感知器的训练
        epoch2 = tr2.epoch;         
        perf2 = tr2.perf;
        iw2 = net2.IW{1};
        b2 = net2.b{1};
        a2 = sim(net2,p2);          %第二层进行仿真
        save Percept02 net1 net2
        if a2 == t2                 %结束条件,当训练结果满足目标向量时结束训练
            index = 1;
        end
    end
    

    展开全文
  • 感知器进行线性分类,结果经过验证,希望可以帮到有需要的人
  • 单层感知器MATLAB代码

    2020-04-21 19:37:39
    单层感知器(Single Layer Perceptron)是最简单的神经网络。它包含输入层和输出层,而输入层和输出层是直接相连的。 与最早提出的MP模型不同,神经元突触权值可变,因此可以通过一定规则进行学习。可以快速、可靠地...
  • 第3章 单层感知器线性神经网络 3.1 生物神经网络 一个多输入单输出非线性系统的动态过程 3.2 单层感知器 3.2.1单层感知器介绍 f(x)称为激活函数,可以理解为信号在轴突上进行的线性或非线性变化。 sign(x)激活...

    第3章 单层感知器与线性神经网络


    3.1 生物神经网络


    一个多输入单输出非线性系统的动态过程

    3.2 单层感知器


    3.2.1单层感知器介绍

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iMxBob6l-1628850028124)(attachment:image-2.png)]

    f(x)称为激活函数,可以理解为信号在轴突上进行的线性或非线性变化。

    sign(x)激活函数

    当x>0 时,输出值为1;当x=0 时,输出值为0,;当x<0 时,输出值为-1

    3.2.2单层感知器计算举例

    假如有一个单层感知器有3 个输入 x 1 , x 2 , x 3 x_1,x_2,x_3 x1,x2,x3,同时已知b=-0.6, 𝑤 1 = 𝑤 2 = 𝑤 3 𝑤_1=𝑤_2=𝑤_3 w1=w2=w3=0.5,
    单层感知器的计算公式𝑓(Σi(𝑤i𝑥i) + 𝑏),则:
    𝑥 1 = 0 , 𝑥 2 = 0 , 𝑥 3 𝑥_1=0, 𝑥_2=0, 𝑥_3 x1=0,x2=0,x3=0:sign(0.5 × 0 + 0.5 × 0 + 0.5 × 0 − 0.6) = −1
    𝑥 1 = 0 , 𝑥 2 = 0 , 𝑥 3 𝑥_1=0, 𝑥_2=0, 𝑥_3 x1=0,x2=0,x3=1:sign(0.5 × 0 + 0.5 × 0 + 0.5 × 1 − 0.6) = −1

    3.2.3单层感知器的另一种表达形式

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eToWMDkO-1628850028126)(attachment:image-3.png)]

    偏置也作为一个输入神经元,b = x 0 w 0 x_0w_0 x0w0 = w 0 w_0 w0
    表达形式更加简洁,更适合使用矩阵来进行运算。

    3.3 单层感知器的学习规则

    x1,x2,…xn对应于w1,w2,…wn等权值,然后利用公式$\Delta w = \eta(\hat y - y) $ 不断调整,更新权值,知道与真实值一样为止。

    3.3.1单层感知机的学习规则介绍

    3.3.2单层感知机的学习规则计算举例

    见下面代码段1,用两种方法展现,一个是普通算法,一个是向量化,很明显向量化高效。

    3.4 学习率

    (1)学习率𝜼取值一般取0-1之间;
    (𝟐)学习率太大容易造成权值调整不稳定;
    (3)学习率太小,模型参数调整太慢,迭代次数太多。

    3.5模型的收敛条件

    通常模型的收敛条件可以有以下3 个:
    (1)loss小于某个预先设定的较小的值;
    (2)两次迭代之间权值的变化已经很小了;
    (3)设定最大迭代次数,当迭代超过最大次数就停止。

    3.6模型的超参数和参数的区别

    超参数:人为设置的一些模型相关的参数。比如说前面提到的学习率,学习
    率需要根据经验来人为设置。比如模型的迭代次数,也是需要在模型训练之前预先进行人为设
    置。
    参数:模型中需要训练的变量。如权值和偏置。

    3.7单层感知器分类案例

    题目:假设我们有4 个2 维的数据,数据的特征分别是(3,3),(4,3),(1,1),(2,1)。(3,3),(4,3)
    这两个数据的标签为1,(1,1),(2,1)这两个数据的标签为-1。构建神经网络来进行分类。

    1. 通常数据有几个特征(几维)就设几个输入神经元,偏置可以做一个输入神经元也可以不做

    2. 向量化同时计算所有数据的预测值,利用矩阵乘法,维度为保持一致,可以加一个1,在乘法过程中,会发现转化为偏置。

    3. ,但是使用单层感知器来做分类的时候,最后得到的分类边界距离某一个类别比较近,而距离另一个类别比较远,并不是一个特别理想的分类效果。图3.7 中的分类效果应该才是比较理想的分类效果,分界线在两个类别比较中间的位置。
      代码见下面。(第三个)

    3.8 线性神经网络

    3.8.1线性神经网络介绍

    线性神经网络跟单层感知器非常类似,只是把单层感知器的sign激活函数改成了purelin
    函数:
    𝑦 = 𝑥

    3.8.2线性神经网络分类案例

    3.9 线性神经网络处理异或问题

    1. 异或规则:

    (1) 0与0异或等于0;

    (2) 0与1异或等于1;

    (3) 1与0异或等于1;

    (4) 1与1异或等于0。

    总结:相同的为0,相异的为1

    1. 线性神经网络引入非线性解决异或问题

    线性神经网络解决不了异或问题,在图像中可以很明显的看出一条直线是不可能将两个类别划分开的,必须引入非线性特征,非线性特征可以从原有特征拼凑。
    代码见下面:引入非线性特征前与引入非线性特征后的对比。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N5arVPLP-1628850028127)(attachment:image-4.png)]

    #单层感知器学习规则计算举例(普通计算)
    
    #导入 numpy科学计算包
    import numpy as np
    #定义输入
    x0 = 1
    x1 = 0
    x2 = -1
    #定义权值
    w0 = -5
    w1 = 0
    w2 = 0
    #定义正确的标签
    t = 1
    #定义学习率lr(learning rate)
    lr = 1
    #定义偏置值
    b = 0
    #循环一个比较大的次数,比如100
    for i in range(100):
        #打印权值
        print(w0,w1,w2)
        #计算感知器的输出
        y = np.sign(w0*x0 + w1*x1 + w2*x2)
        #如果感知器的输出不等于正确的标签
        if(y != t):
            #更新权值
            w0 = w0 + lr*(t-y)*x0
            w1 = w1 + lr*(t-y)*x1
            w2 = w2 + lr*(t-y)*x2
        #如果感知器输出等于正确的标签
        else:
            # 训练结束
            print('done')
            #退出循环
            break
    
    
    -5 0 0
    -3 0 -2
    -1 0 -4
    done
    
    #单层感知器学习规则计算举例(矩阵运算)
    
    #导入numpy科学计算包
    import numpy as np
    
    #定义输入,用大写字母表示矩阵
    #一般我们习惯用一行来表示一个数据,如果存在多个数据就用多行来表示
    X = np.array([[1,0,-1]])
    #定义权值,用大写字母表示矩阵
    #神经网络中权值的定义可以参考神经网络的输入是输出神经元的个数
    #在本例子中输入神经元个数是3个,输出神经元个数是1个,所以可以定义3行1列的W
    W = np.array([[-5],
        [0],
        [0]])
    
    #定义正确的标签
    t = 1
    #定义学习率lr(learning rate)
    lr = 1
    #定义偏置值
    b = 0
    #循环一个比较大的次数,比如100
    for i in range(100):
        #打印权值
        print(W)
        #计算感知器的输出,np.dot可以看做是矩阵乘法
        y = np.sign(np.dot(X,W))
        #如果感知器输出不等于正确的标签
        if(y != t):
            #更新权值
            #X.T表示X矩阵的转置
            #这里一个步骤可以完成代码3-1中下面3行代码完成的事情
            #w0 = w0 + lr*(t-y)*x0
            #w1 = w1 + lr*(t-y)*x1
            #w2 = w2 + lr*(t-y)*x2
            W = W + lr*(t-y)*X.T
            #如果感知器输出等于正确的标签
        else:
            #训练结束
            print('done')
            #退出循环
            break
    
    [[-5]
     [ 0]
     [ 0]]
    [[-3]
     [ 0]
     [-2]]
    [[-1]
     [ 0]
     [-4]]
    done
    
    #单层感知器案例
    import numpy as np
    import matplotlib.pyplot as plt
    #定义输入,我们习惯上用一行代表一个数据
    X = np.array([[1,3,3],
                  [1,4,3],
                  [1,1,1],
                  [1,2,1]])
    #定义标签,我们习惯上用一行表示一个数据的标签
    T = np.array([[1],
                  [1],
                  [-1],
                  [-1]])
    
    #权值初始化,3行1列
    #np.random.random可以生成0-1的随机数
    #括号里填的是数据形状,可以用[],也可以用()
    W = np.random.random([3,1])
    #print(W)
    #学习率设置
    lr = 0.1
    #神经网络输出(初始化预测值为0)
    Y = 0
    
    #更新一次权值
    def train():
        #使用全局变量W
        global W
        #同时计算4个数据的预测值
        #Y的形状为(4,1)-4行1列
        Y = np.sign(np.dot(X,W))
        # T - Y 得到4个的标签值与预测值的误差E。形状为(4,1)
        E = T - Y
        #X.T表示X的转置矩阵,形状为(3,4)
        # 我们一共有4 个数据,每个数据3 个值。定义第i 个数据的第j 个特征值为xij
        # 如第1 个数据,第2 个值为x12
        # X.T.dot(T - Y)为一个3 行1 列的数据:
        # 第1 行等于:x00×e0+x10×e1+x20×e2+x30×e3,它会调整第1 个神经元对应的权值
        # 第2 行等于:x01×e0+x11×e1+x21×e2+x31×e3,它会调整第2 个神经元对应的权值
        # 第3 行等于:x02×e0+x12×e1+x22×e2+x32×e3,它会影调整3 个神经元对应的权值
        # X.shape 表示X的形状X.shape[0]得到X的行数,表示有多少个数据
        # X.shape[1]得到列数,表示每个数据有多少个特征值。
        # 这里的公式跟书中公式3.2看起来有些不同,原因是这里的计算是矩阵运算,书中公式3.2是单个元素的计算。如果在草稿子上仔细推算的话你会发现它们的本质是一样的
        delta_W = lr*(X.T.dot(E))/X.shape[0]
        W = W + delta_W
    #训练100次
    for i in range(100):
        #更新一次权值
        train()
        #打印当前训练次数
        print('epoch:',i+1)
        #打印当前权值
        print('weighets:',W)
        #计算当前输出
        Y = np.sign(np.dot(X,W))
        #.all()表示Y中的所有值跟T中所有值都对应相等
        if(Y==T).all():
            print("当前周期数:",i+1)
            print("当前权值:",W)
            print("当前结果:",Y)
            #print("finished")
            print('Finished')
            #跳出循环
            break
        
        
    
    epoch: 1
    weighets: [[ 0.2335144 ]
     [-0.08645354]
     [-0.07396917]]
    epoch: 2
    weighets: [[0.2835144 ]
     [0.21354646]
     [0.17603083]]
    epoch: 3
    weighets: [[0.1835144 ]
     [0.06354646]
     [0.07603083]]
    epoch: 4
    weighets: [[ 0.0835144 ]
     [-0.08645354]
     [-0.02396917]]
    epoch: 5
    weighets: [[0.1835144 ]
     [0.26354646]
     [0.27603083]]
    epoch: 6
    weighets: [[0.0835144 ]
     [0.11354646]
     [0.17603083]]
    epoch: 7
    weighets: [[-0.0164856 ]
     [-0.03645354]
     [ 0.07603083]]
    epoch: 8
    weighets: [[-0.0664856 ]
     [-0.08645354]
     [ 0.02603083]]
    epoch: 9
    weighets: [[0.0335144 ]
     [0.26354646]
     [0.32603083]]
    epoch: 10
    weighets: [[-0.0664856 ]
     [ 0.11354646]
     [ 0.22603083]]
    epoch: 11
    weighets: [[-0.1664856 ]
     [-0.03645354]
     [ 0.12603083]]
    当前周期数: 11
    当前权值: [[-0.1664856 ]
     [-0.03645354]
     [ 0.12603083]]
    当前结果: [[ 1.]
     [ 1.]
     [-1.]
     [-1.]]
    Finished
    
    #--------------------以下为画图部分--------------------#
    #正样本的xy坐标
    x1 = [3,4]
    y1 = [3,3]
    #负样本的xy坐标
    x2 = [1,2]
    y2 = [1,1]
    
    #计算分类边界线的斜率以及截距
    #神经网络的信号总和为w0*x0+w1*x1+w2*x2
    #当信号总和大于0再进过激活函数,模型的预测值会得到1
    #当信号总和小于0再进过激活函数,模型的预测值会得到-1
    #所以当信号总和w0*x0+w1*x1+w2*x2=0时为分类边界线表达式
    #我们在画图的时候把x1,x2分别看成是平面坐标系中的x和y
    #可以得到,w0+w1*x+w2*y = 0
    #经过通分:y = -w0/w2 - w1*x/w2,因此可以得到:
    k = -W[1]/W[2]
    d =  -W[0]/W[2]
    print(k,d)
    #设定两个点  
    xdata = (0,5)
    #通过两个点来确定一条直线,用红色的线来画出分界线
    plt.figure(figsize=(6.8,4.5),dpi=200)
    plt.plot(xdata,xdata*k+d,'r')
    #用蓝色的点画出正样本
    sample_p = plt.scatter(x1,y1,c='b')
    #用黄色的点来画出负样本
    sample_n = plt.scatter(x2,y2,c='y')
    #添加图例
    #设置图例并且设置图例的字体及大小
    font1 = {'family' : 'Times New Roman',
    'weight' : 'bold',
    'size'   : 11,
    }
    legend = plt.legend(handles=[sample_p,sample_n],labels=["positive sample","negative sample"],loc="lower right",prop=font1)
    #plt.legend(handles=[sample_p,sample_n],labels=["positive sample","negative sample"],loc="lower right",fontsize=12)
    #显示图案
    #plt.savefig("D:\\yyx\\图片\\python_fig1.svg",dpi=500)
    plt.show()
    
    
    [0.28924306] [1.32099103]
    

    在这里插入图片描述

    #线性神经网络--处理异或问题
    #(1)---旧模型无法解决异或问题
    import numpy as np
    import matplotlib.pyplot as plt
    #输入数据
    #4个数据分别对应0与0异或,0与1异或,1与0异或,1与1异或
    X = np.array([[1,0,0],
                  [1,0,1],
                  [1,1,0],
                  [1,1,1]])
    
    #标签,分别对应4种异或情况的结果
    #注意这里我们使用-1作为负标签
    T = np.array([[-1],
                  [1],
                  [1],
                  [-1]])
    
    #权值初始化,3行1列
    #np.random.random可以生成0-1的随机数
    W = np.random.random([3,1])
    
    #学习率设置
    lr = 0.1
    #神经网络输出
    Y = 0
    
    #更新一次权值
    def train():
        #使用全局变量W
        global W
        #计算网络预测值
        Y = np.dot(X,W)
        #计算权值的改变
        delta_W = lr*(X.T.dot(T-Y))/X.shape[0]
        #更新权值
        W = W + delta_W
    #训练100次
    for i in range(100):
        #更新一次权值
        train()
    
    #计算预测结果并打印
    Y = np.dot(X,W)
    print(Y)
        
    #---------------------以下为画图部分-----------------#
    #正样本
    x1 = [0,1]
    y1 = [1,0]
    #负样本
    x2 = [0,1]
    y2 = [0,1]
    
    #计算分界线的斜率以及截距
    # ̄へ ̄#
    k = -W[1]/W[2]
    d = -W[0]/W[2]
    
    #设定两个点
    xdata = (-2,3)
    #通过两个点来确定一条直线,用红色的线来画出分界线
    plt.figure(figsize=(3.2,4.5),dpi=200)
    plt.plot(xdata,xdata*k+d,'r')
    #用蓝色的点画出正样本
    plt.scatter(x1,y1,c='b')
    #用黄色的点来画出负样本
    plt.scatter(x2,y2,c='y')
    #添加图例
    #设置图例并且设置图例的字体及大小
    font1 = {'family' : 'Times New Roman',
    'weight' : 'bold',
    'size'   : 7.5,
    }
    legend = plt.legend(handles=[sample_p,sample_n],labels=["positive sample","negative sample"],loc="lower right",prop=font1)
    
    #保存图片
    #plt.savefig("D:\\yyx\\图片\\python_fig2.svg",dpi=500)
    #显示图案
    plt.show()
    
    [[-0.1089797 ]
     [-0.00796449]
     [-0.02623974]
     [ 0.07477546]]
    

    在这里插入图片描述

    #线性神经网络映入非线性特征解决异或问题
    import numpy as np
    import matplotlib.pyplot as plt
    #输入数据
    #原来X的3个特征分别为:x0,x1,x2
    #X = np.array([[1,0,0],
    #              [1,0,1],
    #             [1,1,0],
    #            [1,1,1]])
    # 给网络输入非线性特征
    # 现在X的6个特征分别为:x0,x1,x2,x1*x1,x1*x2,x2*x2
    X = np.array([[1,0,0,0,0,0],
                  [1,0,1,0,0,1],
                  [1,1,0,1,0,0],
                  [1,1,1,1,1,1]])
    #标签,分别对应4种异或情况的结果
    T = np.array([[-1],
                  [1],
                  [1],
                  [-1]])
    #权值初始化,6行1列
    #np.random.randon可以生成0-1的随机数
    W = np.random.random([6,1])
    #学习率设置
    lr = 0.1
    #神经网络输出
    Y = 0
    
    #更新一次权值
    def train():
        #使用全局变量W
        global W
        #计算网络预测值
        Y = np.dot(X,W)
        #计算误差
        E = T-Y
        #计算权值的改变
        delta_W = lr * (X.T.dot(T - Y)) / X.shape[0]
        #delta_W = lr*np.dot(X.T,E)/X.shape[0]
        #更新权值
        W = W+delta_W
    #训练1000次
    for i in range(1000):
        #更新一次权值
        train()
    #计算预测结果并打印
    Y = np.dot(X,W)
    print(Y)
    
    #-------------------以下为画图部分-------------------#
    #正样本
    x1 = [0,1]
    y1 = [1,0]
    #负样本
    x2 = [0,1]
    y2 = [0,1]
    
    #神经网络信号的总合为:w0x0+w1x1+w2x2+w3x1x1+w4x1x2+w5x2x2
    #当w0x0+w1x1+w2x2+w3x1x1+w4x1x2+w5x2x2=0时为分类边界线(-1与1肯定在0两边)
    #其中x0为1,我们可以把x1,x2分别看成是平面坐标洗中的x和y
    #可以得到:w0+w1x+w2y+w3xx+w4xy+w5yy = 0
    #通分可得:w5y^2 + (w2+w4x)y + w0 + w1x + w3x^2 = 0
    #其中a = w5,b = w2+w4x,c = w0 +w1x + w3x^2
    #根据一元二次方程的求根公式:ay^2+b^y+c=0,y=[-b+/-(b^2-4ac)^(1/2)]/2a
    def calculate(x,root):
        #定义参数
        a = W[5]
        b = W[2]+x*W[4]
        c = W[0]+x*W[1]+x*x*W[3]
        #有两个根
        if root == 1:
            return (-b+np.sqrt(b*b-4*a*c))/(2*a)
        if root==2:
            return (-b-np.sqrt(b*b-4*a*c))/(2*a)
        
    #从-1到2之间均匀生成100个点
    xdata = np.linspace(-1,2,100)
    
    #使用第一个求根公式计算出来的结果画出第一条红线
    plt.figure(figsize=(3.2,4.5),dpi=200)
    plt.plot(xdata,calculate(xdata,1),'r')
    #使用第二个求根公式计算出来的结果画出第二条红线
    plt.plot(xdata,calculate(xdata,2),'r')
    #蓝色点表示正样本
    plt.plot(x1,y1,'bo')
    #黄色点表示负样本
    plt.plot(x2,y2,'yo')
    
    #添加图例
    #设置图例并且设置图例的字体及大小
    font1 = {'family' : 'Times New Roman',
    'weight' : 'bold',
    'size'   : 7.5,
    }
    legend = plt.legend(handles=[sample_p,sample_n],labels=["positive sample","negative sample"],loc="lower right",prop=font1)
    
    #保存图片
    #plt.savefig("D:\\yyx\\图片\\python_fig2.svg",dpi=500)
    #绘图
    plt.show()
    
    
    [[-0.9864406 ]
     [ 0.99094536]
     [ 0.99094536]
     [-0.99299371]]
    

    在这里插入图片描述

    
    
    展开全文
  • Perceptron线性分类器概述一个简单的单层感知器神经网络,具有3个输入层,1个隐藏层和1个输出层。 感知器将根据线性边界线进行线性分类,并使用一组训练点收敛到该边界线。技术信息perceptron算法包含在Perceptron....
  • 神经网络的基础组件:单层感知器

    千次阅读 2019-02-27 22:28:39
    单层感知器属于单层前向网络,即除输入层和输出层之外,只拥有一层神经元节点。前向网络的特点是,**输入数据从输入层经过隐藏层向输出层逐层传播,相邻两层的神经元之间相互连接, 同一层的神经元之间则没有连接。*...

    1 感知器概念

    • 单层感知器属于单层前向网络,即除输入层和输出层之外,只拥有一层神经元节点。前向网络的特点是,**输入数据从输入层经过隐藏层向输出层逐层传播,相邻两层的神经元之间相互连接, 同一层的神经元之间则没有连接。**感知器(perception)是由美国学者 F.Rosenblatt 提出的。
    • 与人工神经网络领域中最早提出的MP模型不同, 它的神经元突触权值是可变的,因此可以通过一定规则进行学习。感知器至今仍是一种十分重要的神经网络模型,可以快速、 可靠地解决线性可分的问题

    1.1 单层感知器的结构

    • 单层感知器是感知器中最简单的一种,由单个神经元组成的单层感知器只能用来解决线性可分的二分类问题。将其用于两类模式分类时,就相当于在高维样本空间中,用一个超平面将样本分开
    • 单层感知器由一个线性组合器和一个二值阈值元件组成。 输入向量的各个分量先与权值相乘,然后在线性组合器中进行叠加,得到的结果是一个标量。 线性组合器的输出是二值阈值元件的输入,得到的线性组合结果经过一个二值阙值元件由隐含层传送到输出层,实际上这一步执行了一个符号函数。二值阔值元件通常是一个上升的函数, 典型功能是将非负的输入值映射为 1,负的输入值映射为-1或0。
    • 考虑一个两类模式分类问题: 输入是一个N维向量x = [x1,x2,x3,…,xn],其中的每一个分量都对应一个权值wi,隐含层的输出叠加为一个标量值:
      ∑ i = 1 N x i w i \sum_{i=1}^N{x_iw_i} i=1Nxiwi
    • 随后在二值阈值元件中对得到的v值进行判断,产生二值输出:
      y = { 1 v ≥ 0 − 1 z &lt; 0 y=\begin{cases} 1 &amp; v\geq0 \\ -1 &amp; z&lt;0 \\ \end{cases} y={11v0z<0

    -w507

    • 单层感知器可以将输入数据分为两类:l1或l2。当y=1时,认为输入的xk来源于l1;当y=-1时认为输入xk属于l2

    • 除了N维向量外,还有一个外部偏置,值恒为1,权值为b,结果图如4-1所示。

    • 输出y可以表示为
      s g n ( ∑ i = 1 N x i w i + b ) sgn(\sum_{i=1}^N{x_iw_i+b}) sgn(i=1Nxiwi+b)

    • 单层感知器进行模式识别的超平面由下式决定:
      ∑ i = 1 N x i w i + b = 0 \sum_{i=1}^N{x_iw_i+b}=0 i=1Nxiwi+b=0

    • 当维度数N=2时,输入项两科表示为平面直角坐标系中的一个点。此时分类超平面是一条直线:
      w 1 x 1 + w 2 x 2 + b = 0 w_1x_1+w_2x_2+b=0 w1x1+w2x2+b=0

    • 假设有三个点,分为两类,第一类包括点(3,0)和(4,-1),第二类包括点(0,2.5)。选择权值为w1=2,w2=-3,b=1,平面上坐标点的分类情况如图所示:
      -w335

    • 二维空间中的超平面是一条直线。在直线下方的点,输出v>0,因此y=1属于l1类;在直线上方的点,输出v<0,因此y=-1,属于l2类。

    1.2 单层感知器的学习算法

    • 方便起见,修改单层感知器的结构图如图4-3所示,将偏置作为固定输入。定义(N+1)*1的输入向量:
      x ( n ) = [ + 1 , x 1 ( n ) , x 2 ( n ) , . . . , x N ( n ) ] T x(n)=[+1,x_1(n),x_2(n),...,x_N(n)]^T x(n)=[+1,x1(n),x2(n),...,xN(n)]T

    • 这里的n表示迭代次数。相应的,定义(N+1)*1权值向量:
      w ( n ) = [ b ( n ) , w 1 ( n ) , w 2 ( n ) , . . . w N ( n ) ] T w(n)=[b(n),w_1(n),w_2(n),...w_N(n)]^T w(n)=[b(n),w1(n),w2(n),...wN(n)]T
      -w344

    • 因此线性组合器的输出为
      v ( n ) = ∑ i = 0 N w i x i = w T ( n ) x ( n ) v(n)=\sum_{i=0}^Nw_ix_i=w^T(n)x(n) v(n)=i=0Nwixi=wT(n)x(n)

    • 令上式等于零,即得二分类问题的决策面。

    • 学习算法步骤如下:

      (1) 定义变量和参数。

      • x(n) = N+1维输入向量
        = [ + 1 , x 1 ( n ) , x 2 ( n ) , . . . , x N ( n ) ] T =[+1,x_1(n),x_2(n),...,x_N(n)]^T =[+1,x1(n),x2(n),...,xN(n)]T
      • w(n) = N+1维权值向量
        = [ b ( n ) , w 1 ( n ) , w 2 ( n ) , . . . , w N ( n ) ] T =[b(n),w_1(n),w_2(n),...,w_N(n)]^T =[b(n),w1(n),w2(n),...,wN(n)]T
      • b(n) = 编置
      • y(n) = 实际输出
      • d(n) = 期望输出
      • η = 学习率参数,是一个比1小的正数

      (2)初始化。n=0,将权值向量w设置为随机值或者全零值。
      (3)激活。输入训练样本,对每个训练样本 x ( n ) = [ + 1 , x 1 ( n ) , x 2 ( n ) , . . . , x N ( n ) ] T x(n)=[+1,x_1(n),x_2(n),...,x_N(n)]^T x(n)=[+1,x1(n),x2(n),...,xN(n)]T
      (4)计算实际输出 y ( n ) = s g n ( w T ( n ) x ( n ) ) y(n) = sgn(w^T(n)x(n)) y(n)=sgn(wT(n)x(n))
      (5)更新权值向量 w ( n + 1 ) = w ( n ) + η [ d ( n ) − y ( n ) ] x ( n ) w(n+1)=w(n)+η[d(n)-y(n)]x(n) w(n+1)=w(n)+η[d(n)y(n)]x(n)
      这里:
      d ( n ) = { + 1 x ( n ) ⊂ l 1 − 1 x ( n ) ⊂ l 2 0 &lt; η &lt; 1 d(n)=\begin{cases} +1 &amp; x(n)\subset l_1 \\ -1 &amp; x(n)\subset l_2\\ \end{cases}\\0&lt;η&lt;1 d(n)={+11x(n)l1x(n)l20<η<1
      (6)判断。若满足收敛条件,则算法结束;若不满足,则n自增1(n+=1),转到第3步继续执行。
      那么,收敛条件是什么呢?当权值向量w已经能正确实现分类时,算法就收敛了,此时网络的误差为0.在计算时,收敛条件通常可以是:

    • 误差小于某个预先设定的较小ε。即 ∣ ( d ( n ) − y ( n ) ) &lt; ε ∣ \left|(d(n)-y(n))&lt;ε\right| (d(n)y(n))<ε

    • 两次迭代之间的权值变化已经很小,即 ∣ ( w ( n + 1 ) − w ( n ) &lt; ε ∣ \left|(w(n+1)-w(n)&lt;ε\right| (w(n+1)w(n)<ε

    • 设定最大迭代次数为M,当迭代了M次后算法自动停止迭代。

    • 为避免偶然收敛,可以要求多次满足收敛误差才停止迭代。

    • 另一个需要通过经验事先确定的参数是学习率η。η的值决定了误差对权值的影响大小:

      • η不应当过大,以便为输入向量提供一个比较稳定的权值估计。
      • η不应当过小,以便使权值能够根据输入的向量x实时变化, 体现误差对权值的修正作用。
      • 注意,我们在调整学习率的时候可以把学习率想象成显微镜的准焦螺旋,**如果只用粗准焦螺旋,调节效率很高,但可能永远也调整不到合适的对焦范围;如果只用细准焦螺旋,调节效率高,但调节的时间可能非常久,最好的方式是先调节粗准焦螺旋到合适的位置,再调节细准焦螺旋。(这个例子非常重要)**对于学习率,也同样是如此,先选择大步长,再选择小步长,使参数按照一定规律变化,对于迭代的收敛有非常好的帮助。
    • 单层感知器并不对所有二分类问题收敛,它只对线性可分的问题收敛,即可通过学习, 调整权值, 最终找到合适的决策面, 实现正确分类。对于线性不可分的问题, 单层感知器 的学习算法是不收敛的, 无法实现正确分类, 如图4-4和图4-5所示。
      -w629

    1.4 单层感知器的局限

    • 感知器的激活函数使用阐值函数, 使得输出只能取两个值(1/-1 或0/1),这样就限制了在分类种类上的扩展。
    • 感知器网络只对线性可分的问题收敛,这是最致命的一个缺陷。根据感知器收敛定理,只要输入向量是线性可分的,感知器总能在有限的时间内收敛。若问题不可分,则感知器无能为力。
    • 如果输入样本存在奇异样本, 则网络需要花费很长的时间。奇异样本就是数值上 远远偏离其他样本的数据。例如以下样本: x ( n ) = [ 1 , − 1 , 2 , − 100 ; 0 , − 1 , 0.5 , 200 ] x(n)=[1,-1,2,-100;0,-1,0.5,200] x(n)=[1,1,2,100;0,1,0.5,200]
    • 每列是一个输入向量。前三个样本数值上都比较小,第四个样本数据则特别大,远远偏离其他数据点,这种情况下,感知器虽然也能收敛,但需要更长的训练时间。
    • 感知器的学习算法只对单层有效,因此无法直接套用其规则设计多层感知器。

    1.4 单层感知器相关函数详解

    MATLAB神经网络工具箱中用于单层感知器设计最重要的函数是newp、train 和sim, 分别用来设计、训练和仿真。涉及的其他函数还有init、adapt、mae、hardlim、learnp 等,本节将选择部分比较重要的函数加以介绍。

    1.4.1 newp-创建一个感知器

    函数语法如下:
    net=newp(P,T,TF,LF)
    newp函数用于生成一个感知神经网络,以解决线性可分的分类问题。后两个输入参数是可选的,如果采用默认值,可以简单地才用net=newp(P,T)的形式来调用。

    • P:P是一个R*2矩阵,矩阵的行数R等于感知器网络中输入向量的维度。矩阵每一行表示输入向量每个分量的取值范围。如P=[-1,1:0,1],表示输入向量是2维向量[x1,x2],且-1≤x1≤1,0≤x2≤1。因此,矩阵R的第二列数字必须大于等于第一列数字,否则系统将会报错。
    • T:表示输出节点的个数,标量。
    • TF:传输函数,可取值为hardlim或hardlims,默认值为hardlim。
    • net:函数返回创建好的感知器网络。
      newp函数创建的感知器如图4-6所示,网络拥有R个输入节点,T个输出节点。
      -w508
    • learnpn函数与pearnp函数区别在于,learnpn对输入量大小变化比learnp不敏感。当输入的向量在数值的幅度上变化比较大时,使用learnpn代替learnp,可以加快计算速度。
    • 用newrb函数创建一个感知器,并进行训练仿真。
    ·>> p=[-1,1;-1,1]    %输入向量有两个分量,两个分量取值范围均为-1~1
    
    p =
    
        -1     1
        -1     1
    
    >> t = 1;      %共有一个输出节点
    >> net(p,t)      %创建感知器
    未定义函数或变量 'net'。
     
    >> p=[-1,1;-1,1]		% 输入向量有两个分量,两个分量取值范围均为-1~1
    
    p =
    
        -1     1
        -1     1
    
    >> t=1;			% 共有1个输出节点
    net=newp(p,t);		% 创建感知器
    P=[0,0,1,1;0,1,0,1]	% 用于训练的输入数据,每列是一个输入向量
    
    P =
    
         0     0     1     1
         0     1     0     1
    
    >> T=[0,1,1,1]		% 输入数据的期望输出
    
    T =
    
         0     1     1     1
    
    >> net=train(net,P,T);	% train函数用于训练
    >> newP=[0,0.9]';		% 第一个测试数据
    >> newT=sim(net,newP)	% 第一个测试数据的输出为0
    
    newT =
    
         0
    
    >> newP=[0.9,0.9]';		% 第二个测试数据
    >> newT=sim(net,newP)	% 第二个测试数据的输出为1
    
    newT =
    
         1
    
    >> newT=sim(net,P)		% 用原训练数据做测试,实际输出等于期望输出
    
    newT =
    
         0     1     1     1
    
    >> 
    

    -w392
    训练结果如图所示,我们可以看到,创建的感知器网络有两个输入节点,一个输出节点。

    1.4.2 train——训练感知网络 P111

    用于训练创建好的感知器网络,语法如下:
    [net,tr] = train(net,P,T,Pi,Ai)

    样例
    % example4_2.m
    p=[-100,100]                    % 输入数据是标量,取值范围-100~100
    % p =
    % 
    %   -100   100
    
    t=1                             % 网络含有一个输出节点
    % t =
    % 
    %      1
    
    net=newp(p,t);                  % 创建一个感知器
    P=[-5,-4,-3,-2,-1,0,1,2,3,4]	% 训练输入
    % P =
    % 
    %     -5    -4    -3    -2    -1     0     1     2     3     4
    
    T=[0,0,0,0,0,1,1,1,1,1]         % 训练输出,负数输出0,非负数输出1
    % T =
    % 
    %      0     0     0     0     0     1     1     1     1     1
    
     net=train(net,P,T);            % 用train’进行训练
     newP=-10:.2:10;                % 测试输入
    newT=sim(net,newP);             % 测试输入的实际输出
    plot(newP,newT,'LineWidth',3);
    title('判断数字符号的感知器');
    
    训练结果

    -w613

    4.4.3 sim——对训练好的网络进行仿真 P113

    用于仿真一个神经网络。函数的语法格式如下:

    1. [Y,Pf,Af] = sim(net,P,Pi,Ai)
    2. [Y,Pf,Af,E,perf] = sim(...)

    4.4.4 hardlim/hardlims——感知器传输函数

    • hardlim和hardlims都是感知器的传输函数,其功能类似于数学上的符号函数。
      s g n ( x ) = { 1 v &gt; 0 0 v = 0 − 1 v &lt; 0 sgn(x)=\begin{cases} 1 &amp; v&gt;0 \\ 0 &amp; v=0 \\ -1 &amp; v&lt;0 \end{cases} sgn(x)=101v>0v=0v<0
      1. A=hardlim(N,FP)A=hardlims(N,FP)
      1. dA_dN=hardlim('dn',N,A,FP)dA_dN=hardlim('dn',N,A,FP)

    1.4.5 init——神经网络初始化函数

    net = init(net)

    1.4.6 adapt——神经网络的自适应

    [net,Y,E,Pf,Af,tr] = adapt(net,P,T,Pi,Ai)

    1.4.7 mae——平均绝对误差性能函数

    perf=mea(E)

    展开全文
  • 对分布于二维空间的线性可分样本进行分类,画出了其中每个类的判决函数、判决面。 并拓展到非线性可分或者不可分!
  • 深度学习(神经网络)[1] —— 单层感知器算法描述python实现示例运行结果可视化 算法描述 最原始的神经网络模型,类似于神经网络中的单个神经元,该算法局限性也很大,只适用于解决线性可分的问题和异或问题,对于...
  • 感知器原理及线性分类技术实现

    千次阅读 2018-10-26 23:29:00
    在说起感知器之前,需要先说一下神经网络的定义: 神经网络是由具有适应性的简单单元组成的广泛并行互联的网络,它的组织能够模拟生物神经系统对真实世界物体所作出的交互反应。 感知器(M-P神经元模型) ...
  • 生物医学工程实验,单层感知器的设计,1.使用 Matlab 编程实现单层感知器。2. 调节学习率η,观察对于不同学习率算法的收敛速度(迭代次数) 3. 用单层感知器处理非线性分类问题,观察结果。
  • 单层感知器

    2018-03-27 17:36:09
    基于深度学习实现单层感知器的python代码,用单层感知器处理非线性分类问题,观察结果。
  • 单层感知器 SLP 是一种仅由一个神经元(感知器)组成的神经网络。 它可以接收无限数量的输入并将它们线性分离。 这是我正在处理的作业中的一小段代码,它演示了如何编写单层感知器来确定一组 RGB 值是红色还是蓝色...
  • 目录单层感知器基础理论知识MATLAB神经网络工具箱使用例程算法实现参考文献单层感知器基础理论知识关于单层感知器的理论知识与MATLAB中单层感知器相关函数,在单层感知器--matlab神经网络这篇文章中有详细的讲解。...
  • 感知器单层感知器用于线性分类
  • 目录单层感知器基础理论知识MATLAB神经网络工具箱使用例程算法实现参考文献单层感知器基础理论知识关于单层感知器的理论知识与MATLAB中单层感知器相关函数,在单层感知器--matlab神经网络这篇文章中有详细的讲解。...
  • 单层感知器1、单层感知器介绍2、单层感知器计算示例3、单层感知器的另一种表达形式4、单层感知器的学习规则4.1 学习规则介绍4.2 单层感知器的学习规则计算5、代码实战5.1 单层感知器学习规则计算举例5.1.1 简单的...
  • 单层感知器神经网络matlab代码混沌系统的建模与建模 大家好,我叫Jobin Sunny,我来自里贾纳大学。 该项目旨在使用人工神经网络对显示混沌频谱的非线性动力系统进行长期预防和建模。 在这项工作中,我将先解释一下我...
  • 神经网络——单层感知器

    千次阅读 2022-02-02 19:42:44
    神经网络——单层感知器 单层感知器是感知器中最简单的一种,只能用来解决线性可分的二分类问题。 matlab神经网络原理与实例精解 陈明 等编著 第4章 单层感知器 P124
  • # 单层感知器应用实例——坐标点的分类问题 问题描述:给定二维平面的六个点,利用单层感知器进行分类 一、手算 给定六个点,如下图1-1所示: 序号 X Y 所属类型 1 -9 15 0 2 1 8 1 3 -12 4 0 4 -4 ...
  • 这篇文章简单介绍了人工智能中单层感知器相关方面的知识。
  • 感知机(单层感知机)可视化 matlab实现。 博文链接:https://blog.csdn.net/weixin_43290523/article/details/105972154
  • 单层感知器简要说明

    千次阅读 2020-05-18 15:39:37
    单层感知器算法是神经网络算法中结构最简单的模型,作为一种线性分类器,它可以对两种类型进行线性分类。感知器是生物神经细胞的简单抽象,是神经网络的原型,是以最简单的方式模拟人类神经元的算法。 神经元图示: ...
  • C语言实现单层感知器

    2021-05-25 01:07:43
    根据perceptron 学习规则(Rosenblatt 提出 )用C语言实现单层感知器。代码如下。#include#includeint nTrain=7; //训练样本数量int nInput=3; //训练样本维度double delta=0.1; //学习速率int nTest=1; //测试样本...
  • python实现irst的单层感知器学习
  • 感知器介绍感知器(Perceptron),是神经网络中的一个概念,在1950s由Frank Rosenblatt第一次引入。单层感知器(Single Layer Perceptron)是最简单的神经网络。...单层感知器由一个线性组合器和一个...
  • example4_1~example4_7为第四节【单层感知器...perception_hand.m为第五节【单层感知器应用实例】手算部分的代码,修改后用于线性不可分问题的代码为perception_hand_un.m。 使用工具箱函数的代码为perception_fcn。
  • MATLAB快速入门,单层感知器线性神经网络,BP神经网络,反馈神经网络,随机神经网络,GUI设计神经网络等等
  • 训练样本矩阵: P = [0.1 0.7 0.8 0.8 1.0 0.3 0.0 –0.3 –0.5 –1.5; 1.2 1.8 1.6 0.6 0.8 0.5 0.2 0.8 –1.5 –1.3];...训练样本对应的分类: T = [1 1 1 0 0 1 1 1 0 0 ;0 0 0 0 0 1 1 1 1 1...
  • 单层感知器的原理及代码实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,458
精华内容 2,583
热门标签
关键字:

单层感知器线性分类