为了账号安全,请及时绑定邮箱和手机立即绑定
  • 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


  • 对人类智商和尊严进行全面的碾压...

  • 感知器数据分类算法步骤

    01:28
    看视频
  • file=""
    import pandas as pd
    import matplotlib.pyplot  as plt
    import numpy as np
    df=pd.read_cvs(flie,header=none)//文件第一行即数据第一行
    
    y=df.loc[0:100,4].values//读取数据,将0-100行数据的第四列,作为输出y(vector)
    y=np.where(y=="",1,-1)//将输出字符串转化成数字
    x=df.loc[0:100,[0,2]].values//第0列和第2列作为输入抽取出来
    
    plt.scatter(x[:50,0],x[:50,1],color='red',marker='o',label="xxx")
    plt.scatter(x[50:100,0],x[50:100,1],color='blue',marker='x',label="yyy")
    plt.xlabel('lll')
    plt.ylabel('mmm')
    plt.legend(loc='upper left')//设置图例属性
    plt.show()


    11:23
    看视频
  • 感知器算法 试用范围:

    1. Linearly separable 线性可分割 √

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


  • 阈值的更新

        阈值

            一开始是 根据我们的经验,设定一个值

            这个值再后续中要不断的更新。

            就是 w0 的更新。没有x0可以乘。

    θ = -w0 

    wo = w0 + dw0

    dw0 = η * e(y)



  • 权重更新算法:

    wj = wj + dwj

    dwj = η * (y - y^) * xj

           = η * e(y) * xj 

    η:学习率,是[0, 1]间的一个小数。

        需要模型的设计者自己去设定。模型自己训练中不断地调整权重w的取值。然鹅,不同的学习率η,有可能会影响到最后的模型学习效果。




  • 步调函数 & 阈值

    z* = z - theta  (????)

    z* ><  2* theta


  • 感知器 数据分类算法 步骤:

    1. 把权重向量w初始化为0(或[0, 1]间任意小数);

    2. 把训练样本输入感知器,得到分类结果(-1, 或1);

    3. 根据分类结果更新权重向量w 。


    整个机器学习的目的,就是 通过输入的训练样本,反复去更新权重向量w,直到权重向量更新到一定程度之后,我们的整个模型才能有效地对未知输入做出有效的分类和预测。


  • 老师没有把代码贴出来,光看老师讲映像不够深刻,还是要自己动手。同学把自己整理的代码贴出来给大家看看:

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

  • 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


  • import numpy as np
    class Perceptron(object):
        """    
        eta:学习率    
        n_iter:权重向量的训练次数    
        w_:神经分叉权重向量    
        errors:用于记录神经元判断出错次数    
        """
        def __init__(self, eta, n_iter):        
            self.eta=eta        
            self.n_iter=n_iter        
            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
        def fit(self,X,y):        
            """        
            输入训练数据,训练神经元,x输入样本向量,y对应样本的正确分类                
            X:shape[n_samples, n_features]        
            eg:X:[[1, 2, ,3],[4, 5, 6]]           
               n_samples: 2           
               n_features: 3                      
               y:[1, -1]        
            """        
            """        
            初始化权重向量为0        
            加一是因为前面算法提到的w0,也就是步调函数阈值        
            """        
            self.w_ = np.zeros(1+X.shape[1])        
            self.errors_ =[]                
            
            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 是一个向量                
                    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   
        pass
    
    
    file = "D:/PyCharm_test_file/Jupyter_test/iris1.xlsx"
    import pandas as pd
    
    df = pd.read_excel(file,header=None)
    #df.head(10)
    #print(df)  
    
    
    import matplotlib.pyplot as plt
    import numpy as npy = df.loc[0:99, 4].values
    y = np.where(y == 'Iris-setosa', -1, 1)
    #print(y)
    X = df.iloc[0:100, [0, 2]].values
    #print(X)
    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='vericolor')
    plt.rcParams['font.sans-serif']=['SimHei']
    plt.xlabel('花瓣长度')
    plt.ylabel('花茎长度')
    plt.legend(loc='upper left')
    plt.show()  
    
    
    
    from matplotlib.colors import ListedColormap
    def plot_decision_regions(X, y, classifier, resolution=0.02):    
        marker = ('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()    
        x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max()    
        #将x1、x2最大最小值通过arange函数得到的向量,扩展成两个二维矩阵    
        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) #ravel还原成单维向量    
        #绘制    
        Z= Z.reshape(xx1.shape) #将Z转换成与xx1一样的二维数组    
        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=marker[idx], label=cl)
            
            
    ppn = Perceptron(0.1, 10)
    ppn.fit(X, y)
    plot_decision_regions(X, y, ppn, resolution=0.02)


  • 自适应线性神经元的分类算法

    class AdalineGD(object):
        def __init__(self, eta=0.1, n_iter=50):
            self.eta = eta
            self.n_iter = n_iter
        def fit(self, X, y): #与感知器最大的不同
            self.w_ = np.zeros(1 + X.shape[1])
            self.cost_ = [] #成本函数:判断改进效果,使其不断减小
            for i in range(self.n_iter):
                output = self.net_input(X)
                errors = y - output
                self.w_[1:] += self.eta * X.T.dot(errors)
                self.w_[0] += self.eta * errors.sum()
                cost = (errors ** 2).sum()/2.0
                self.cost_.append(cost)
            return self
        def net_input(self, X):
            return np.dot(X, self.w_[1:] + self.w_[0])
        def activation(self, X):
            return self.net_input(self, X):
        def predict(self, X):
            return np.where(self.activation(X) >= 0, 1, -1)
    
    #运行算法               
    ada = AdalineGD(eta=0.0001, n_iter=50) #学习率越低,每次权重的改进越精确;迭代次数越大,优化的结果越准确。
    ada.fit(X, y)
    plot_decision_regions(X, y, classifier=ada) #预测数据输入到神经网络后预测
    plt.title('Adaline-Gradient descent')
    plt.xlabel('花茎长度')
    plt.ylabel('花瓣长度')
    plt.legend(loc='upper left')
    plt.show()
    
    plt.plot(range(1, len(ada.cost_)+1), ada.cost_, marker='o') #检测改进效果
    plt.xlabel('Epochs') #自我迭代的学习次数
    plt.ylabel('sum-squard-error') #做出错误判断的次数
  • 感知器的激活函数是步调函数,当输入数据大于阈值-->1,小于阈值-->0.

    自适应线性神经元的激活函数是直接将输入数据与参数相乘后求和:w0+x1w1+x2w2+……,并且会将计算结果与输入结果进行比较,若不一致,会根据给定结果动态调整参数-->渐进下降法。

    渐进下降法:

    和方差函数(U型),当函数对w求偏导后得到的切线斜率小于0(大于0)-->增大(减小)相应神经元参数w值


    01:39
    看视频
  • 数据解析和可视化

    import pandas as pd
    import matplotlib.pyplot as plt
    import numpy as np
    
    df = pd.read_csv(file, header=None)
    y = df.loc[0:100, 4].values
    y = np.where(y == 'Iris-setosa', -1, 1)
    X = df.iloc[0:100, [0, 2]].values
    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.show()

    数据分类(将预测的数据输入到神经网络中,以图形方式绘制)

    from matplotlib.colors import ListedColormap
    def plot_decision_regions(X, y, classifier, resolution=0.02):
        marker = ('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()
        x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max()
        #将x1、x2最大最小值通过arange函数得到的向量,扩展成两个二维矩阵
        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) #ravel还原成单维向量
        #绘制
        Z= Z.reshape(xx1.shape) #将Z转换成与xx1一样的二维数组
        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=cl)
  • 感知器的分类算法

    import numpy as mp
    class Perception(objet):
        def __init__(self, eta=0.01, n_ier=10): #eta学习率,n_iter训练权重向量的重复次数
            self.eta = eta
            self.n_iter = n_iter
        #根据输入样本培训神经元,X:shape[n_sample, n_feature], n_feature指神经元接收的电信号X数量
        def fit(self, X, y): 
            self.w_ = np.zero(1+X.shape[1]) #初始权重向量w_为0,括号里加一是包括激励函数的阈值w0
            self.errors_ = [] #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)
             
            def net_input(self, X): #输入电信号X与权重w的点积
                return np.dot(X, self.w_[1:]) + self.w_[0]
                
            def predict(self, X): #预测分类
                return np.where(self.net_input(X) >= 0.0, 1, -1)


  • 感知器算法:要求数据线性可分

  •     机器学习中用于对数据进行分类的算法:1.感知器。2.适应性的线性神经元。

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

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

  • 神经元的数学表示

    激活函数

    向量的转置与乘积的表达式

首页上一页1234567下一页尾页

举报

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