精华内容
下载资源
问答
  • 感知器分类
    2022-05-04 22:19:48

    单层感知器分类案例

    1、题目及实现思路

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

      思路:我们要分类的数据是 2 维数据,所以只需要 2 个输入节点(一般输入数据有几个特征,我们就设置几个输入神经元),我们可以把神经元的偏置值也设置成一个输入节点。这样我们需要 3 个输入节点。

      输入数据有 4 个(1,3,3),(1,4,3),(1,1,1),(1,2,1)

      数据对应的标签为(1,1,-1,-1)

      初始化权值 w1,w2,w3 取 0 到 1 的随机数

       学习率 lr(learning rate)设置为 0.1

      激活函数为 sign 函数

      我们可以构建一个单层感知器如图所示。

    image-20220504221540251

    2、代码实战

    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])
    # 学习率设置
    lr = 0.1
    # 神经网络输出
    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('weights:',W)
        # 计算当前输出 
        Y = np.sign(np.dot(X,W)) 
        # .all()表示Y中的所有值跟T中所有值都对应相等,结果才为真
        if(Y == T).all(): 
            print('Finished')
            # 跳出循环
            break
    
    #————————以下为画图部分————————#
    # 正样本的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]
    # 设定两个点
    xdata = (0,5)
    # 通过两个点来确定一条直线,用红色的线来画出分界线
    plt.plot(xdata,xdata * k + d,'r')
    # 用蓝色的点画出正样本
    plt.scatter(x1,y1,c='b')
    # 用黄色的点来画出负样本
    plt.scatter(x2,y2,c='y')
    # 显示图案
    plt.show()
    

    结果:

    image-20220504221706262

      因为权值的初始化使用的是随机的初始化方式,所以每一次训练的周期以及画出来的图 可能都是不一样的。这里我们可以看到单层感知器的一个问题,虽然单层感知器可以顺利地 完成分类任务,但是使用单层感知器来做分类的时候,最后得到的分类边界距离某一个类别 比较近,而距离另一个类别比较远,并不是一个特别理想的分类效果。

    更多相关内容
  • 鸢尾花感知器分类.zip

    2019-05-09 15:26:46
    里面有MATLAB感知器算法的实现 以及鸢尾花UCI数据集,可以对鸢尾花实行两分类
  • 感知器分类,使用matlab!!!!!!
  • 感知器分类

    2014-12-18 22:13:45
    单层感知器成功分类的事例,亲测可运行,希望有帮助
  • 感知器算法,用于感知器的计算,感知器指的是进行分类的线性判别函数,他们不需要考虑模式及的统计性质。
  • 基于感知器分类器设计方法,能有效地进行分类
  • 感知器神经元解决较复杂输入向量的分类问题
  • 模式识别分类器,本代码是感知器,训练数据在压缩包的fisher1.txt中
  • 感知器分类结果.fig

    2019-06-13 21:24:26
    设计一个分类器,其中分类器必须包含特性的选择和提取
  • 资源名:感知器分类算法分离三类样本_每个分类面都将一类与其他所有的类分开_matlab 资源类型:matlab项目全套源码 源码说明: 全部项目源码都是经过测试校正后百分百成功运行的,如果您下载后不能运行可联系我进行...
  • 感知器是一种将输入有监督地分类为几个可能的非二进制输出之一的算法。 这个 mfile 是一种简单的感知器类型,适合喜欢了解人工神经网络感知器类型的人
  • 分类算法有两种类型:感知器和适应性线性神经元 神经元的数学表示 [1234] \begin{bmatrix} 1 & 2 \\ 3 & 4 \\ \end{bmatrix} [13​24​]

    分类算法有两种类型:感知器和适应性线性神经元

    神经元的数学表示

    w = [ w 1 w 2 . . . w m ] , x = [ x 1 x 2 . . . x m ] w=\begin{bmatrix} w_1 \\ w_2 \\ ... \\ w_m \\ \end{bmatrix} , x=\begin{bmatrix} x_1 \\ x_2 \\ ... \\ x_m\\ \end{bmatrix} w=w1w2...wm,x=x1x2...xm
    z = w 1 x 1 + w 2 x 2 + ⋅ ⋅ ⋅ + w m x m z=w_1x_1 + w_2x_2 + ···+w_mx_m z=w1x1+w2x2++wmxm
    其中w为权重,x为训练样本

    感知机的训练步骤

    1. 把权重向量初始化为0,或把每个分向量初始化为[0,1]间任意小数
    2. 把训练样本输入感知机,得到分类结果(-1或1)
    3. 根据分类结果更新权重向量

    激活函数

    为了计算方便我们添加 w 0 x 0 w_0x_0 w0x0, 其中 w 0 = − θ , x 0 = 1 w_0=-\theta,x_0=1 w0=θx0=1
    z = w 0 x 0 + w 1 x 1 + . . . + w m x m = w T x , ϕ ( z ) = { 1 if z>0 − 1 , otherwise z=w_0x_0 + w_1x_1+...+w_mx_m = w^Tx , \phi(z)=\begin{cases} 1 & \text {if z>0} \\ -1, & \text{otherwise} \end{cases} z=w0x0+w1x1+...+wmxm=wTx,ϕ(z)={11,if z>0otherwise
    这样,当 z > 0 z>0 z>0时, ϕ ( z ) = 1 \phi(z)=1 ϕ(z)=1,当 z < 0 z<0 z<0时, ϕ ( z ) = − 1 \phi(z)=-1 ϕ(z)=1.

    权重的更新算法

    • w ( j ) = w ( j ) + Δ w ( j ) w(j)=w(j)+\Delta w(j) w(j)=w(j)+Δw(j)
    • Δ w ( j ) = η ∗ ( y − y ′ ) ∗ x ( j ) \Delta w(j)=\eta*(y-y')*x(j) Δw(j)=η(yy)x(j) : y表示x(j)的正确分类,y’表示感知机算出来的分类,x(j)表示训练样本。可以看出来如果感知器的分类结果 y ′ y' y与正确分类 y y y相同时,那么可以得到 Δ w ( j ) = 0 \Delta w(j)=0 Δw(j)=0,也就可以得到 w ( j ) = 0 w(j)=0 w(j)=0,也就是说如果感知器可以正确对数据样本进行正确分类,那么对权重 w ( j ) w(j) w(j)就不需要进行调整;只有感知器得到了错误的分类结果之后,出需要调整权重向量 w ( j ) w(j) w(j)
    • η \eta η 表示学习率是[0,1]之间的一个小数,一般有使用者自己设置。通过反复运行模型,人为根据经验调整学习率 η \eta η,使得模型训练结果越来越好。
    • w ( 0 ) = 0 , Δ w ( 0 ) = η ∗ ( y − y ′ ) w(0)=0, \Delta w(0)=\eta*(y-y') w(0)=0,Δw(0)=η(yy)阈值的更新

    举例说明如何更新权重

    假设

    1. 权重向量初始化为: w = [ 0 , 0 , 0 ] w=[0,0, 0] w=[0,0,0]
    2. 训练样本的值: x = [ 1 , 2 , 3 ] x=[1,2,3] x=[1,2,3]
    3. 学习率: η = 0.3 \eta=0.3 η=0.3
    4. 这个样本的正确分类y=1
    5. 感知器算出来的分类是y’=-1

    调整权重向量 Δ w ( 0 ) = 0.3 ∗ ( 1 − ( − 1 ) ) ∗ x ( 0 ) = 0.3 ∗ 2 ∗ 1 = 0.6 \Delta w(0)=0.3*(1-(-1))*x(0)=0.3*2*1=0.6 Δw(0)=0.3(1(1))x(0)=0.321=0.6 w ( 0 ) = w ( 0 ) + Δ w ( 0 ) = 0.6 w(0) = w(0)+\Delta w(0)=0.6 w(0)=w(0)+Δw(0)=0.6,则权重的第一个分量更新为0.6,即 w = [ 0.6 , 0 , 0 ] w=[0.6,0,0] w=[0.6,0,0]

    同理, Δ w ( 1 ) = 0.3 ∗ ( 1 − ( − 1 ) ) ∗ x ( 1 ) = 0.3 ∗ 2 ∗ 2 = 1.2 \Delta w(1)=0.3*(1-(-1))*x(1)=0.3*2*2=1.2 Δw(1)=0.3(1(1))x(1)=0.322=1.2,则更新权重的第二个分量为 w ( 1 ) = w ( 1 ) + Δ w ( 1 ) = 1.2 w(1)=w(1)+\Delta w(1)=1.2 w(1)=w(1)+Δw(1)=1.2

    同理, Δ w ( 2 ) = 0.3 ∗ ( 1 − ( − 1 ) ∗ x ( 2 ) ) = 0.3 ∗ 2 ∗ 3 = 1.8 \Delta w(2)=0.3*(1-(-1)*x(2))=0.3*2*3=1.8 Δw(2)=0.3(1(1)x(2))=0.323=1.8,则更新权重的第三个分量为 w ( 2 ) = w ( 2 ) + Δ w ( 2 ) = 1.8 w(2)=w(2)+\Delta w(2)=1.8 w(2)=w(2)+Δw(2)=1.8

    最终可以得到更新后的权重向量为 w = [ 0.6 , 1.2 , 1.8 ] w=[0.6, 1.2, 1.8] w=[0.6,1.2,1.8]

    这样就可以再次将新的训练样本输入到模型中,根据分类结果走相同的步骤继续改进权重向量。

    感知器算法的适用范围

    在这里插入图片描述
    必须要满足上图中第一个图中的情况,也就是预测的数据可以现行分割,感知器的训练目标就是要找出这条线。而后面两个情况,是无法进行线性可分的,不适用于感知器算法进行分类。

    代码实现

    定义感知器类

    import numpy as np
    
    class Perceptron(object):
        """
        eta: 学习率
        n_iter: 权重向量的训练次数
        w_: 神经分叉权重向量
        errors_: 用于记录神经元判断出错次数
        """
        def __init__(self, eta = 0.01, n_iter = 10):
            self.eta = eta
            self.n_iter = n_iter
            pass
        
        def fit(self, X, y):
            """
            输入训练数据,培训神经元,X表示输入样本, y对应样本的正确分类
            X: shape[n_samples, n_features]
            n_samples:表示有多少个训练样本数量
            n_features: 表示有多少个属性
            例如:X: [[1,2,3], [4,5,6]] => n_samples=2;n_features=3
    
            y: [1, -1]表示第一个向量的分类是1, 第二个向量的分类是-1
            """
    
            """
            首先初始化权重为0
            加一是因为激活函数w0,也就是阈值,这样就只用判断输出结果是否大于0就可以了
            """
            self.w_ = np.zero(1 + X.shape[1])
            self.errors_ = []
    
            """
    		只要出现错误分类,那么反复训练这个样本,次数是n_iter
    		"""
            for _ in range(self.n_iter): 
                errors = 0
                """
                X:[[1,2,3], [4,5,6]]
                y:[1, -1]
    
                zip(X, y) => [[1,2,3,1], [4,5,6-1]]
                """
                for xi, target in zip(X,y):
                    """
                    update = η * (y-y')
                    """
                    update = self.eta * (target - self.predict(xi))
                    """
                    xi 是一个向量, 例如[1,2,3], target表示1
                    update 是一个常量
                    update*xi 等价于 [Δw(1) = X[1]*update, Δw(2) = X[2]*update, Δw(3) = X[3]*update]
                    """
                    # w_[1:]表示w忽略第0个元素,从第一个元素开始往后
                    self.w_[1:] += update * xi
                    self.w_[0] += update * 1
                    errors += int(update != 0.0)
                    self.errors_.append(errors)
                pass
            pass
                
        def net_input(self, X):
            """
            z = W0*1 + W1*X1 + W2*X2+ ...+ Wn*Xn
            """
            return np.dot(X, self.w_[1:]) + self.w_[0]
    
        def predict(self, X):
            """
            如果self.net_input(X) >= 0.0返回1, 否则返回-1
            """
            return np.where(self.net_input(X) >= 0.0 , 1, -1)
    

    目前虽然有了感知器的分类算法,但是还没有运行起来,下面将如何使用这个感知器分类算法,然后将训练样本输入到模型中,最后进行预测数据。

    介绍训练数据

    有了基本模型后,要做的就是要把大量的数据,输入至模型中,让模型通过对大量数据的观察,总结出数据中隐含的某种规律,根据数据特点不断调节模型中神经元权重数值,当神经元的权重数值调节到合适的范围之内后,就可以利用训练后的模型对新的数据进行预测分类。
    首先需要先介绍训练数据的数据结构。训练数据内容如下:
    在这里插入图片描述
    使用pandas工具,来读取数据,可以很容易的进行抽取数据。
    首先安装pandas:pip install pandas -i https://pypi.douban.com/simple

    import pandas as pd
    
    file="./iris.csv"
    df = pd.read_csv(file, header=None)
    print(df.head())
    

    结果输出如下:
    在这里插入图片描述
    可视化展示这个数据,使用matplotlib工具进行展示。

    import matplotlib.pyplot as plt
    import numpy as np
    from test3 import df
    
    # 将df中0到100行的数据的第四列赋值给y向量 
    y = df.loc[0:100, 4].values
    # 将Iris-setosa转为-1,其余转为1
    y = np.where(y == 'Iris-setosa', -1, 1)
    # print(y)
    # 将df0到100行的数据的第0列和第2列抽取出来,赋值给x向量
    X = df.iloc[0:100, [0, 2]].values
    # print(X)
    # 将X向量的钱50条数据的第0列作为x轴,第1列作为y轴坐标,画在二维坐标轴,画出来的点是红色的'o',
    plt.scatter(X[:50, 0], X[:50, 1], color = 'red', marker='o', label='setosa')
    plt.scatter(X[50:100, 0], X[50:100, 1], color = 'blue', marker='x', label='versicolor')
    plt.xlabel('花瓣长度')
    plt.ylabel('花径长度')
    plt.legend(loc='upper left')
    # 下面两行解决乱码问题
    plt.rcParams['font.sans-serif'] = ['KaiTi'] # 指定默认字体
    plt.rcParams['axes.unicode_minus'] = False
    
    plt.show()
    

    在这里插入图片描述
    可以看出来这两类数据可以线性分割开。

    一步一步调试

    初始化eta=0.1, w=[0 0 0]
    
    5.1,1.4,target=-1, self.net_input(x)=W0*1+W1*5.1+W2*1.4=0,self.predict(xi)=1,update=eta*(target-self.predict(xi))=0.1*(-2)=-0.2,errors=1,W=[1*(-0.2)5.1*(-0.2)1.4*(-0.2)]=[-0.2 -1.02 -0.28]
    4.9,1.4,target=-1, self.net_input(x)=W0*1+W1*4.9+W2*1.4=-0.2*1+(-1.02)*4.9+(-0.28)*1.4=-0.3918432<0,self.predict(xi)=-1,update=eta*(target-self.predict(xi))=0.1*0=0,errors=1,W=[-0.2+1*0-1.02+4.9*0-0.28+1.4*0]=[-0.2 -1.02 -0.28]
    4.7,1.3,target=-1, self.net_input(x)=W0*1+W1*4.7+W2*1.3=-0.2+(-4.794)+(-0.364)<0,self.predict(xi)=-1,update=0,errors=1,W=[-0.2 -1.02 -0.28]
    5.4,1.7,target=-1,self.net_input(x)<0,self.predict(xi)=-1,update=0,errors=1,W=[-0.2 -1.02 -0.28]
    7,4.7,target=1,self.net_input(x)<0,self.predict(xi)=-1,update=0.2,errors=2,W=[(-0.2)+(0.2*1) (-1.02)+(0.2*7) (-0.28)+(0.2*4.7)]=[0 0.38 0.66]
    
    1. 首先得到样本数据和分类标签target
    2. 然后计算预测标签的值predict
    3. 更新权重W=eta*(target-predict), 将上一次的权重W进行累加w(j)+Δw(j)
    4. 以此类推
    展开全文
  • 基于Python的单层感知器分类算法的实现.pdf
  • 感知器分类器的两种不同方式一种是通过MATLAB命令(感知器)训练一层感知器网络,另一种是我根据感知器理论和梯度下降公式编写的程序。 (还添加了演示文件)。 绘制了所有分类线。 在程序中,如果最大迭代达到一条...
  • 感知器分类模型回顾与python实现

    千次阅读 2019-03-30 15:09:10
    今天有一个任务需求就是要使用感知器分类模型来对我们手里面的数据集进行简单的分类实验,我们都知道感知器是一种比较简单的线性分类器,只能够处理线性可分的样本数据,为了再回顾一下上学时候的内容,我特意翻出来...

            今天有一个任务需求就是要使用感知器分类模型来对我们手里面的数据集进行简单的分类实验,我们都知道感知器是一种比较简单的线性分类器,只能够处理线性可分的样本数据,为了再回顾一下上学时候的内容,我特意翻出来以前的文档,下面是感知器算法的简单介绍:

                   

           简单看过原理后,我们看下下面这一个简单的算法实例:
                                             

                                  

          关于感知分类器详细地介绍的文章,网上还有很多很多,我这里就不再多解释了,相信上面的算法原理和算法实例只要认真看完手推计算一遍之后就没什么问题了。

          下面我们来进行简单的实现,具体如下:

    #!usr/bin/env python
    #encoding:utf-8
    
    '''
    __Author__:沂水寒城
    功能:  感知器分类模型实践demo
    '''
    
    
    import os
    import sys
    import xlrd
    import numpy as np
    import matplotlib.pyplot as plt
    from matplotlib.colors import ListedColormap
    
    
    if sys.version_info<(3,0):
        #python2版本使用
        reload(sys)
        sys.setdefaultencoding("utf-8")
    
    
    class myPerceptron(object):
        '''
        感知器分类模型
        '''
    
        def __init__(self,eta=0.01,n_iter=10):
            '''
            初始化
            '''
            self.eta=eta
            self.n_iter=n_iter
    
    
        def fit(self, X, y):
            '''
            拟合器
            '''
            self.w_=np.zeros(1+X.shape[1]) # Add w_0
            self.errors_=[]
            for _ in range(self.n_iter):
                errors=0
                for xi,target in zip(X,y):
                    update=self.eta*(target-self.predict(xi))
                    self.w_[1:]+=update*xi
                    self.w_[0]+=update
                    errors+=int(update!=0.0)
                self.errors_.append(errors)
            return self
    
    
        def inputCal(self, X):
            '''
            计算
            '''
            print('W====>  ',self.w_[:].tolist())
            X_dot=np.dot(X,self.w_[1:])+self.w_[0]
            return X_dot
    
    
        def predict(self, X):
            '''
            预测
            '''
            return np.where(self.inputCal(X)>=0.0,1,-1) 
    
    
    def readOneExcelData(data='data/data.xlsx',row=1,col=1):
        '''
        row: 起始行索引
        col: 起始列索引
        '''
        workbook=xlrd.open_workbook(data,'rb')
        table=workbook.sheets()[0]
        row_num,col_num=table.nrows,table.ncols
        data_list=[]
        for i in range(row,row_num):
            one_list=[]
            for j in range(col,col_num):
                one_list.append(table.cell_value(i,j)) 
            data_list.append(one_list)
        X_list=[one[:-1] for one in data_list]
        y_list=[one[-1] for one in data_list]
        return np.array(X_list),np.array(y_list)
    
    
    def originalDataPloter(X,save_path='original_data.png'):
        '''
        对原始数据进行可视化
        '''
        plt.clf()
        plt.scatter(X[:2, 0], X[:2, 1],color='red',marker='o',label='0 class')
        plt.scatter(X[2:, 0], X[2:, 1],color='blue',marker='x',label='1 class')
        plt.title('Original Data Distribution')
        plt.legend(loc='upper left')
        plt.savefig(save_path)
    
    
    def resultPloter(X,y,classifier,resolution=0.02,save_path='result.png'):
        '''
        分类结果可视化
        '''
        markers=('s','x','o','^','v')
        colors=('red','blue','lightgreen','gray','cyan')
        cmap = ListedColormap(colors[:len(np.unique(y))])
        x1_min,x1_max=X[:, 0].min()-1,X[:, 0].max()+1
        x2_min,x2_max=X[:, 1].min()-1,X[:, 1].max()+1
        xx1,xx2=np.meshgrid(np.arange(x1_min, x1_max,resolution),np.arange(x2_min, x2_max, resolution))
        Z=classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
        Z=Z.reshape(xx1.shape)
        plt.clf()
        plt.contourf(xx1,xx2,Z,alpha=0.4,cmap=cmap)
        plt.xlim(xx1.min(),xx1.max())
        plt.ylim(xx2.min(),xx2.max())
        for idx, cl in enumerate(np.unique(y)):
            plt.scatter(x=X[y == cl, 0], y=X[y == cl, 1],
            alpha=0.8, c=cmap(idx),
            marker=markers[idx], label=str(cl).split('.')[0].strip()+' class')
        plt.legend(loc='upper left')
        plt.title('myPerceptron Result')
        plt.savefig(save_path)
    
    
    if __name__=='__main__':
        X_list,y_list=readOneExcelData(data='data/data.xlsx',row=1,col=0)
        #原始数据可视化
        originalDataPloter(X_list,save_path='original_data.png')
        #模型训练拟合
        model=myPerceptron(eta=0.01,n_iter=10)
        model.fit(X_list,y_list)
        #结果可视化
        resultPloter(X_list,y_list,model,resolution=0.02,save_path='result.png')

            整体的逻辑是很简单的,代码实现里面加入了数据的可视化部分,我们首先对原始样本的数据进行了可视化,之后分类器训练完成后,对分类结果同样进行了可视化。

          其中,原始数据可视化结果如下:

                                  

          使用训练后的感知器分类模型可视化结果如下:

                                 

          小小的实践,记录一下。 

    展开全文
  • 基于Python的单层感知器分类算法的实现
  • 感知器算法 感知器算法是通过训练模式的迭代和学习算法 产生线性可分的模式判别函数 感知器 算法就是通过对训练模式样本集的学习得出判别函数的系数解在本次实验中我们主 要是采用硬限幅函数进行分类 感知器的训练...
  • 使用四种方法进行鸢尾花分类:最小距离分类器,K 近邻法,感知器,Fisher 准则。
  • 感知器分类算法

    千次阅读 2018-06-19 17:01:33
    感知器算法的适用条件为如下图所示的线性可划分的情况,即可用一条直线来将平面中的样本分为两类。 感知器算法如同人类神经元的工作原理,由众多的分支神经传进电信号,然后经过对这些电信号加权求和,再依据激活...

            感知器算法的适用条件为如下图所示的线性可划分的情况,即可用一条直线来将平面中的样本分为两类。


           感知器算法如同人类神经元的工作原理,由众多的分支神经传进电信号,然后经过对这些电信号加权求和,再依据激活函数来输出相应的信号。

          上图是单层神经网络的数据处理流程,各个分支神经输入的电信号和对应的权重分别采用X1,X2…Xm和W1,W2省略号表示,这里为了激活函数方便处理引入一个新的分支神经,并将其输入信号X0固定为1,权重W0固定为激活函数的阈值的相反数。所以对各分支神经的输入信号的处理变为


    (其中θ为阈值)故从而激活函数可简化为


    所有输入的加权和大于等于0即输出1,其它情况均输出-1。

    在输出错误时,整个感知器要进行权重更新来使分类正确。这里假设样本的正确分类记为,感知器计算出的分类记为,权重更新的公式如下:


    其中为第i个分支的权重需要改变的值,为一个[0,1]区间内的系数称为学习率,其具体的数值需要根据经验自行调整来让感知机效果更好。将加到原来的上即为第i条分支新的权重。在输出错误时,依次将所有权重都更新一遍,这里需要注意的是对于X0这条分支,其权重是阈值,因此阈值也是需要更新的。所有的权重更新完成后,再进行加权求和并将其值带入激活函数判断。这里是一个多次迭代的过程,直至能正确输出结果。

            注:本文仅属个人观点,如有不妥,还望读者私信纠正。


    展开全文
  • 实验报告+代码+数据集 1、掌握Fisher线性判别的基本原理 2、利用Fisher线性判别解决基本的两类线性分类问题 1、熟悉感知器算法。 2、掌握感知准则函数分类器...3、掌握感知器算法,利用它对输入的数据进行多类分类
  • 它包括决策边界图
  • 感知器与SVM分类

    2018-08-18 12:37:26
    分别运用感知器和支持向量机实现了对数据集的分类,可以帮助初学者了解入门。
  • python-机器学习 感知器分类算法

    千次阅读 2018-10-22 14:31:15
    感知器分类算法 一、基本概念 1. 神经元的数学表示 X向量组表示神经元电信号,W 向量组是弱化神经元电信号的系数组合。Z为处理后的信号。 2. 激活函数 3. 向量点积   二、感知器分类算法 1. 感知器数据...
  • 感知器实现

    2016-07-14 09:59:02
    图像处理领域中的感知器是一种有效的线性分类器。本资源利用MATLAB自带的神经网络工具箱实现了感知器。请注意,本资源是MATLAB代码。
  • 资源名:感知器算法_线性分类程序_matlab源码 资源类型:matlab项目全套源码 源码说明: 全部项目源码都是经过测试校正后百分百成功运行的,如果您下载后不能运行可联系我进行指导或者更换。 适合人群:新手及有一定...
  • 设有两个模式样本集合,用感知机算法设计两个模式类的分类判决函数G(x)
  • 资源名:感知器算法分类数据_画出决策面_matlab 资源类型:matlab项目全套源码 源码说明: 全部项目源码都是经过测试校正后百分百成功运行的,如果您下载后不能运行可联系我进行指导或者更换。 适合人群:新手及有...
  • 线性分类感知器设计算法程序,其中利用了低度下降算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,319
精华内容 26,527
关键字:

感知器分类

友情链接: TaskbarIcon.rar