为了账号安全,请及时绑定邮箱和手机立即绑定
  • 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:shapep[n_samples,n_features] x:[[1,2,3],[4,5,6]] n_samples:2 n_features:3 y:[1,-1] """ """ 初始化权重向量为0 加一是因为前面算法提到的w0,也就是步调函数阈值 """ self.w_=np.zero(1+x.shape[1]); self.errors_=[]; pass
  • 老师没有把代码贴出来,光看老师讲映像不够深刻,还是要自己动手。同学把自己整理的代码贴出来给大家看看:

    使用PYTHON实现简单的单一神经元

  • 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,trage in zip(X,y): """ update = n * (y-y') """ update = self.eta * (traget - self.predict(xi)) """ xi是一个向量 update * xi 等价: {W(1) = X[1]*update, W(2) = X[2]*update, W(3) = X[3]*update} """ self.w[1:] += update * xi pass self.w_[0] += update; pass pass def net_input(self, x): """ z = W0*1+W1*X1 + ...+Wn*Xn """ return np.dot(X, self.w_[1:]) + self.w_[0] pass def predict(self, X): return np.where[self.net_input(X) >= 0.0 : 1, -1] pass pass
  •     机器学习中用于对数据进行分类的算法:1.感知器。2.适应性的线性神经元。

        激活函数(也叫单元步调函数)

        机器学习的本质是模拟人的神经元对信息的处理方法。根据神经学的研究,神经元可以看做是一个简单的带有二进制输出功能的逻辑电路门。

  • from matplotlib.colors import ListedColormap
    def plot_decision_region(X, y, classifier, resolution=0.02):
        marker = ('s', 'x', 'o', 'v')
        colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
        cmap = ListColormap(colors[:len(np.unique(y))])
        
        x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max()
        x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max()
        
        # 将np.arange()中的向量扩展成一个矩阵
        '''
        xx1:
        a = np.arange(x1_min, x1_max, resolution) 向量元素为185个
        xx1[255, 185],将a中的元素作为一行,重复255行
        xx2:
        b = np.arange(x2_min, x2_max, resolution) 向量元素为255个
        xx2[255, 185],将b中的元素作为一列,重复185列
        '''
        xx1, xx2 = np.mesbgrid(np.arange(x1_min, x1_max, resolution),
                               np.arrange(x2_min, x2_max, resolution))


  • 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
        def fit(self, X, y):
            '''
            输入训练数据,培训神经元
            X是输入样本向量,y是对应的样本分类
            X:shape[n_samples, n_features]
            X:[[1, 2, 3], [4, 5, 6]]
            n_samples: 2
            n_features: 3
            y:[1, -1]
            '''
            #初始化权重向量为0,加1是因为提到的w0,即步调函数的阈值
            self.w_ = np.zero(1 + X.shape[1])
            self.errora_ = []


  • x(j)电信号

    当感知器计算出错误的分类,才需要调整权重W(j)

    W(j)模型自动改进

    η需要使用者根据具体的使用场景,基于经验来调整

    05:37
    看视频
  • 步调函数(激活)与阈值

    02:48
    看视频
  • 感知器数据分类算法步骤


    01:39
    看视频
  • X = np.array
    X:shape[n_samples , n_features]
    X:[ [1 , 2 , 3] , [4 , 5 , 6] ]
    n_samples : 2  n_features : 3
    X.shape[1]就是X的n_samples值,值为2。


  • import numpy as np

    class perceptron(object):

        '''

        eta:学习率

        n_iter:权重向量的训练次数

        w_:神经分叉权重向量  w处理输入x

        errors_:用于记录神经元判断出错次数

        '''

        def _int_(self,eat=0.01,n_iter=10):

            self.eat=eat;

            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]

            

            """

            '''

            初始化权重向量为0

            w_:是一个一位数组,代表每个神经纤维的权重向量

            X.shape[1]:在计算有几个神经纤维

            加一是因为前面算法提到的w0,也就是步调函数的阈值

            开始的时候阈值  塞它=w0 用w0保存

            '''

            self.w_=np.zero(1+X.shape[1]);

            self.errors=[];

            for _ in range(self.n_iter):

                error=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):

                    '''

                    target:每组数据,一个个神经元 判断的正确值标准值

                    update=学习率*(y-y')

                    '''

                    update=self.eta*(target-self.predict(xi))

                    '''

                    predict:函数,是用来根据每个神经元输入的一组数据得到自己判断的结果

                    xi 是一个向量

                    update*xi等价:

                    [的它w(1)=x[1]*update,的它w(2)=x[2]*update,的它w(3)=x[3]*update,]

                    '''

                    self.w_[1:] +=update*xi

                    self.w_[0] +=update;

                

                

                

                    errors += int(update != 0.0)

                    self.errors_append(errors)   

                    pass

          

                pass

            def net_input(self,x):

                '''

                完成神经元对输入信号的处理(加权点乘)

                '''

                return np.dot(X  , self.w_[1:] + self.w_[0])

                pass

            def predict(self,x):

                              '''

                              加权点乘后用于与阈值判断

                              '''

                return np.where(self.net_input(X) >= 0.0 , 1 , -1)

                pass

            

            pass


  • 感知器算法 试用范围:

    1. Linearly separable 线性可分割 √

    2. Not linearly separable  线性不可分割的 ×


  • iris数据集:

    5.13.51.40.2Iris-setosa
    4.931.40.2Iris-setosa
    4.73.21.30.2Iris-setosa
    4.63.11.50.2Iris-setosa
    53.61.40.2Iris-setosa
    5.43.91.70.4Iris-setosa
    4.63.41.40.3Iris-setosa
    53.41.50.2Iris-setosa
    4.42.91.40.2Iris-setosa
    4.93.11.50.1Iris-setosa
    5.43.71.50.2Iris-setosa
    4.83.41.60.2Iris-setosa
    4.831.40.1Iris-setosa
    4.331.10.1Iris-setosa
    5.841.20.2Iris-setosa
    5.74.41.50.4Iris-setosa
    5.43.91.30.4Iris-setosa
    5.13.51.40.3Iris-setosa
    5.73.81.70.3Iris-setosa
    5.13.81.50.3Iris-setosa
    5.43.41.70.2Iris-setosa
    5.13.71.50.4Iris-setosa
    4.63.610.2Iris-setosa
    5.13.31.70.5Iris-setosa
    4.83.41.90.2Iris-setosa
    531.60.2Iris-setosa
    53.41.60.4Iris-setosa
    5.23.51.50.2Iris-setosa
    5.23.41.40.2Iris-setosa
    4.73.21.60.2Iris-setosa
    4.83.11.60.2Iris-setosa
    5.43.41.50.4Iris-setosa
    5.24.11.50.1Iris-setosa
    5.54.21.40.2Iris-setosa
    4.93.11.50.1Iris-setosa
    53.21.20.2Iris-setosa
    5.53.51.30.2Iris-setosa
    4.93.11.50.1Iris-setosa
    4.431.30.2Iris-setosa
    5.13.41.50.2Iris-setosa
    53.51.30.3Iris-setosa
    4.52.31.30.3Iris-setosa
    4.43.21.30.2Iris-setosa
    53.51.60.6Iris-setosa
    5.13.81.90.4Iris-setosa
    4.831.40.3Iris-setosa
    5.13.81.60.2Iris-setosa
    4.63.21.40.2Iris-setosa
    5.33.71.50.2Iris-setosa
    53.31.40.2Iris-setosa
    73.24.71.4Iris-versicolor
    6.43.24.51.5Iris-versicolor
    6.93.14.91.5Iris-versicolor
    5.52.341.3Iris-versicolor
    6.52.84.61.5Iris-versicolor
    5.72.84.51.3Iris-versicolor
    6.33.34.71.6Iris-versicolor
    4.92.43.31Iris-versicolor
    6.62.94.61.3Iris-versicolor
    5.22.73.91.4Iris-versicolor
    523.51Iris-versicolor
    5.934.21.5Iris-versicolor
    62.241Iris-versicolor
    6.12.94.71.4Iris-versicolor
    5.62.93.61.3Iris-versicolor
    6.73.14.41.4Iris-versicolor
    5.634.51.5Iris-versicolor
    5.82.74.11Iris-versicolor
    6.22.24.51.5Iris-versicolor
    5.62.53.91.1Iris-versicolor
    5.93.24.81.8Iris-versicolor
    6.12.841.3Iris-versicolor
    6.32.54.91.5Iris-versicolor
    6.12.84.71.2Iris-versicolor
    6.42.94.31.3Iris-versicolor
    6.634.41.4Iris-versicolor
    6.82.84.81.4Iris-versicolor
    6.7351.7Iris-versicolor
    62.94.51.5Iris-versicolor
    5.72.63.51Iris-versicolor
    5.52.43.81.1Iris-versicolor
    5.52.43.71Iris-versicolor
    5.82.73.91.2Iris-versicolor
    62.75.11.6Iris-versicolor
    5.434.51.5Iris-versicolor
    63.44.51.6Iris-versicolor
    6.73.14.71.5Iris-versicolor
    6.32.34.41.3Iris-versicolor
    5.634.11.3Iris-versicolor
    5.52.541.3Iris-versicolor
    5.52.64.41.2Iris-versicolor
    6.134.61.4Iris-versicolor
    5.82.641.2Iris-versicolor
    52.33.31Iris-versicolor
    5.62.74.21.3Iris-versicolor
    5.734.21.2Iris-versicolor
    5.72.94.21.3Iris-versicolor
    6.22.94.31.3Iris-versicolor
    5.12.531.1Iris-versicolor
    5.72.84.11.3Iris-versicolor
    6.33.362.5Iris-virginica
    5.82.75.11.9Iris-virginica
    7.135.92.1Iris-virginica
    6.32.95.61.8Iris-virginica
    6.535.82.2Iris-virginica
    7.636.62.1Iris-virginica
    4.92.54.51.7Iris-virginica
    7.32.96.31.8Iris-virginica
    6.72.55.81.8Iris-virginica
    7.23.66.12.5Iris-virginica
    6.53.25.12Iris-virginica
    6.42.75.31.9Iris-virginica
    6.835.52.1Iris-virginica
    5.72.552Iris-virginica
    5.82.85.12.4Iris-virginica
    6.43.25.32.3Iris-virginica
    6.535.51.8Iris-virginica
    7.73.86.72.2Iris-virginica
    7.72.66.92.3Iris-virginica
    62.251.5Iris-virginica
    6.93.25.72.3Iris-virginica
    5.62.84.92Iris-virginica
    7.72.86.72Iris-virginica
    6.32.74.91.8Iris-virginica
    6.73.35.72.1Iris-virginica
    7.23.261.8Iris-virginica
    6.22.84.81.8Iris-virginica
    6.134.91.8Iris-virginica
    6.42.85.62.1Iris-virginica
    7.235.81.6Iris-virginica
    7.42.86.11.9Iris-virginica
    7.93.86.42Iris-virginica
    6.42.85.62.2Iris-virginica
    6.32.85.11.5Iris-virginica
    6.12.65.61.4Iris-virginica
    7.736.12.3Iris-virginica
    6.33.45.62.4Iris-virginica
    6.43.15.51.8Iris-virginica
    634.81.8Iris-virginica
    6.93.15.42.1Iris-virginica
    6.73.15.62.4Iris-virginica
    6.93.15.12.3Iris-virginica
    5.82.75.11.9Iris-virginica
    6.83.25.92.3Iris-virginica
    6.73.35.72.5Iris-virginica
    6.735.22.3Iris-virginica
    6.32.551.9Iris-virginica
    6.535.22Iris-virginica
    6.23.45.42.3Iris-virginica
    5.935.11.8Iris-virginica


  • 基本按着老师的写的,能出图~ 笔记字数有限制,代码分了几部分,注释参考老师的讲解。 (第1段) # -*- coding: utf-8 -*- import numpy as np class Perceptron(object): def __init__(self, eta = 0.01, n_iter=10): self.eta = eta; self.n_iter = n_iter; pass def fit(self, X, y): self.w_ = np.zeros(1 + X.shape[1]); 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) pass pass pass def net_input(self, X): return np.dot(X, self.w_[1:]) + self.w_[0] pass def predict(self, X): return np.where(self.net_input(X) >= 0.0 , 1, -1) pass pass
  • 感知器分类算法 权重和训练样本进行点积,对点积结果求和得到z值,送至激活函数,若z>0,则通过激活函数输出结果为1,若z<0,输出为-1.这样就把数据进行了分类. 当然,其中涉及到权重和阈值的更新.
首页上一页1234567下一页尾页

举报

0/150
提交
取消
课程须知
有一定的编程基础,例如掌握C语言。
老师告诉你能学到什么?
1、机器学习的基本概念介绍 2、数据分类算法介绍 3、神经元感知器分类算法并进行实现 4、数据解析和可视化设计 5、使用数据训练神经网络 6、如何使用训练后的神经网络分类数据 7、适应性线性神经元的基本原理并实现 8、适应性线性神经元网络进行数据分类

微信扫码,参与3人拼团

意见反馈 帮助中心 APP下载
官方微信
友情提示:

您好,此课程属于迁移课程,您已购买该课程,无需重复购买,感谢您对慕课网的支持!