感知器及双月实验

一、定义

  感知器是模仿人类神经元的用于线性可分分类的最简单的神经网络模型。线性可分分类即可以通过一个线性的超平面将数据分开。其基本模型如下图所示，其中$a_1,a_2,...a_n$是输入数据，$w_1,w_2,...,w_n$是权重可以理解为可分超平面的斜率，$b$是偏执保证超平面不过原点，$sum$是简单的求和操作，$f$在感知器中被称为激活函数，实际上是一个限幅器，将输出映射为对应的类别的值域中。

  感知器的数学模型如下：
$$f(x)=\{\begin{array}{ll}1& \text{ if }w\cdot x+b>0\\ -1& \text{ else }\end{array}$$
  公式中的-1，1只是表示两个类别不具备任何具体的含义，可以用其他两个不同的数字代替，其中${\sum }_{i=1}^n{w}_i{x}_i+b=0$便是感知器学习到的可分超平面。感知器一般使用梯度下降，最小二乘和有感知器学习对权重$\text{w}$进行迭代来调整超平面。

二、感知器收敛定理

  对于感知器收敛是可证明的下面就给出相应的收敛定理证明，另外，感知器收敛的前提是数据是线性可分的。

  在感知器中一般$b$只会选取一个固定的值比如+1，-1作为偏置，这里选择+1，因此可以将$b$和$w$合并，因此相应的输入$x$和$w$变成:

$$x=[+1,x_1,x_2,...,x_n{]}^T$$

$$w=[w_0,w_1,w_2,...,w_n{]}^T$$

  其中$x$和$w$分别在第一位添加了一个维度，公式变得更加紧蹙，但是计算结果和过程都不会受到影响。原感知器模型就变成:

$$f(x)=\sum _{i=1}^n{w}_i{x}_i+b\Rightarrow f(x)=\sum _{i=1}^n{w}_i{x}_i={\text{w}}^T\text{x}$$

  感知器更新$w$的方式很简单基本就是惩罚措施，对于正确分类的情况$w$不做任何更新，对于错分的情况才更新$w$，可以认为感知器做错了就打一巴掌，指导他所有都做对了为止。基本的更新规则如下(第一个公式就是对于正确分类，第二个公式就是对于错误分类，$D_1$和$D_2$分别为两个类别):
$$\begin{array}{ll}{w}_{n+1}=w_n& x_n{w}_n^T>0且x_n\in D_1\\ w_{n+1}=w_n& x_n{w}^T⩽0且x_n\in D_2\end{array}$$

$$\begin{array}{ll}{w}_{n+1}=w_n-{\eta }_n{x}_n& x_n{w}_n^T>0且x_n\in D_2\\ w_{n+1}=w_n+{\eta }_n{x}_n& x_n{w}^T⩽0且x_n\in D_1\end{array}$$

  $\eta$表示学习率，通常学习率只会和学习的快慢相关不会和最总的结果有很大的关系。因此我们现在假定学习率$\eta =1$且为常量，而且$w_0=0$，因此对于$w_n$的迭代可以得到：$w_{n+1}=x_1+x_2+...+x_n$，因为两个类别是线性可分的因此一定存在一个线性超平面得到最终的解，假定最终的解为${\text{w}}_o$，因此可以定义一个常数$\alpha$,存在

$$\begin{array}{rl}& \alpha =\underset{x_n\in D_1}{\min }{\text{w}}_o^T{\text{x}}_n\\ & \Rightarrow {\mathbf{w}}_o^T{\mathbf{w}}_{n+1}={\mathbf{w}}_o^T{\mathbf{x}}_1+{\mathbf{w}}_o^T{\mathbf{x}}_2+\cdots +{\mathbf{w}}_o^T{\mathbf{x}}_n\\ & \Rightarrow {\mathbf{w}}_o^T{\mathbf{w}}_{n+1}⩾n\alpha \\ & \Rightarrow {\Vert {\mathbf{w}}_o\Vert }^2\Vert {\mathbf{w}}_{n+1}{\Vert }^2⩾n^2{\alpha }^2因为{\Vert {\mathbf{w}}_o\Vert }^2\Vert {\mathbf{w}}_{n+1}{\Vert }^2⩾{\left[{\mathbf{w}}_o^T{\mathbf{w}}_{n+1}\right]}^2\\ & \Rightarrow \Vert {\mathbf{w}}_{n+1}{\Vert }^2⩾\frac{n^2{\alpha }^2}{{\Vert {\mathbf{w}}_o\Vert }^2}\end{array}$$

  这里证明了$w_n$的下限，另一方面证明其的上限：

$$\begin{array}{rl}& {\mathbf{w}}_{n+1}={\mathbf{w}}_n+{\mathbf{x}}_n\\ & \Rightarrow \Vert {\mathbf{w}}_{n+1}{\Vert }^2=\Vert {\mathbf{w}}_n{\Vert }^2+\Vert {\mathbf{x}}_n{\Vert }^2+2{\mathbf{w}}_n^{\mathrm{T}}{\mathbf{x}}_n,对上式两边同时平方\\ & \Rightarrow \Vert {\mathbf{w}}_{n+1}{\Vert }^2⩽\sum _{k=1}^n\Vert {\mathbf{x}}_k{\Vert }^2⩽n\beta ,其中\beta =\underset{x_n\in {\mathbb{D}}_1}{\max }\Vert {\mathbf{x}}_n{\Vert }^2\end{array}$$

  因此有:

$$\begin{array}{rl}& \frac{n^2{\alpha }^2}{{\Vert {\mathbf{w}}_o\Vert }^2}⩽\Vert {\mathbf{w}}_{n+1}{\Vert }^2⩽\sum _{k=1}^n\Vert {\mathbf{x}}_k{\Vert }^2⩽n\beta ,其中\beta =\underset{x_n\in {\mathbb{D}}_1}{\max }\Vert {\mathbf{x}}_n{\Vert }^2,\alpha =\underset{x_n\in D_1}{\min }{\text{w}}_o^T{\text{x}}_n\\ & \Rightarrow \frac{n_{\max }^2{\alpha }^2}{{\Vert {\mathbf{w}}_{\mathrm{o}}\Vert }^2}=n_{\max }\beta \exists n_{max}\\ & \Rightarrow n_{max}=\frac{\beta ||{\text{W}}_o|{|}^2}{{\alpha }^2}\end{array}$$

  因此对于线性可分的数据集，对于$\eta =0,w_0=0$一定能在一定的迭代次数之后终止。而对于$\eta$非固定时，感知器总是能够在一定步数到达固定的$\eta$中的某个状态，也就是将固定$\eta$分解为多个任务，以不同的$\eta$进行迭代，但最终的效果是相同的，唯一不同的是需要迭代训练的次数增加或者减少。

  感知器算法完整描述:

• 输入:数据：$x=[+1,x_1,x_2,...,x_n{]}^T$, 权值$w=[b,w_1,w_2,...,w_n{]}^T$,实际响应$y_n$期望响应:$d_n$,学习率$\eta$

• 1. 初始化，对输入数据和权重进行初始化；
  2. 激活，通过输入$x$和期望响应$d_n$激活感知器；
  3. 计算实际响应，$y_n=sgn(w_n^T{x}_n)$,$sgn$为符号函数
  4. 更新权值:$w_{n+1}=w_n+\eta (d_n-y_n)x_n$
  5. $n=n+1$转2直到验证的准确率达到阈值为止。

  其中，$$d_n=\{\begin{array}{ll}+1& x\in D_1\\ -1& x\in D_2\end{array}$$

  在学习过程需要注意的是，虽然感知器对线性可分模型一定收敛但是在实际应用中，需要慎重选取$\eta$,希望稳定的更新就需要比较小的$\eta$，可能速度过慢,希望快速更新就需要比较大的$\eta$可能会出现更新过快震荡的情况。

三、贝叶斯分类器

1、高斯环境下的感知器与贝叶斯分类器的关系

  贝叶斯分类器对于二分类问题（两个类别分别为$D_1$,$D_2$），其平均风险为:
$$\begin{array}{rl}\mathcal{R}& =c_{11}{p}_1{\int }_{D_1}{p}_x(x|D_1)dx+c_{22}{p}_2{\int }_{D_2}{p}_x(x|D_2)dx\\ & +c_{21}{p}_1{\int }_{D_1}{p}_x(x|D_1)dx+c_{12}{p}_2{\int }_{D_2}{p}_x(x|D_2)dx\end{array}$$
  其中:

• $P_i$标是变量$x$取自子空间$D_i$的先验概率,$i=1,2$且$p_1+p_2=1$
• $c_{ij}$将$$类识别为$i$类的代价，$i=1,2$
• $p_x(x|D_i)$标是变量$x$的条件概率密度函数,$i=1,2$

  令:$D=D_1+D_2$，可以将上式改写为:
$$\begin{array}{rl}\mathcal{R}& =c_{11}{p}_1{\int }_{D_1}{p}_x(x|D_1)dx+c_{22}{p}_2{\int }_{D-D_1}{p}_x(x|D_2)dx\\ & +c_{21}{p}_1{\int }_{D_1}{p}_x(x|D_1)dx+c_{12}{p}_2{\int }_{D-D_1}{p}_x(x|D_2)dx\end{array}$$
  又因$c_{11}<c_{21},c_{22}<c_{12}$且有${\int }_D{p}_x(x|D_1)dx={\int }_D{p}_x(x|D_2)dx=1$
  则上式简化为
$$\begin{array}{rl}\mathcal{R}& =c_{21}p1+c_{22}p2\\ & +{\int }_{D_1}[p_2(c_{12}-c_{22})p_x(x|D_2)-p_1(c_{21}-c_{11})p(x)(x|D_1)]dx\end{array}$$
  上式中第一项为固定项，为了最小化代价应该最小化第二项，因此最优的分类策列是将使得$p_x(x|D_2)$越小越好，$p_x(x|D_1)$越大越好，假设条件
$$\begin{array}{r}{p}_1(c_{21}-c_{11})p_x(x|D_1)>p_2(c_{12}-c_{22})p_x(x|D_2)\end{array}$$
  定义
$$\begin{array}{r}\Lambda (x)=\frac{p_x(x|D_1)}{p_x(x|D_2)}和\xi =\frac{p_2(c_{12}-c_{22})}{p_1(c_{21}-c_{11})}\end{array}$$
  其中$\Lambda$是拟然比,$\xi$是检验阈值，二者恒正，则贝叶斯分类器可以表述为:
$$\begin{array}{r}\{\begin{array}{l}x\in D_1,\Lambda (x)>\xi \\ x\in D_2,\Lambda (x)\le \xi \end{array}\end{array}$$
  很明显这个分类器和感知器的分类策略很相似，因此贝叶斯分类器和感知器等价。

2、高斯分布下的贝叶斯分类器

  对于高斯分布的情况存在下面的情况:
$$\begin{array}{r}\{\begin{array}{ll}\mathbb{E}[X]={\mu }_1,\mathbb{E}[(X-{\mu }_1)(X-{\mu }_1{)}^T]=C& X\in D_1\\ \mathbb{E}[X]={\mu }_2,\mathbb{E}[(X-{\mu }_2)(X-{\mu }_2{)}^T]=C& X\in D_2\end{array}\end{array}$$
  其中C为协方差，是非对角，即$D_1$$D_2$是相关的，假设C是非奇异的，即逆矩阵$C^{-1}$存在。
  $x$的条件概率密度韩式表示为多变量高斯分布为：
$$\begin{array}{r}{p}_x(x|D_1)=\frac{1}{(2\pi {)}^{m/2}(\Delta (C){)}^{1/2}}{e}^{-\frac{1}{2}(x-\mu {)}^T{C}^{-1}(x-{\mu }_1)},i=1,2,m为x的维数\end{array}$$
  可以进一步假设，数据时均衡的也就是分类成任何一个类的机会是等价的则有，且假设不同的错分类的代价相同，即:
$$\begin{array}{rl}& p_1=p_2=\frac{1}{2}\\ & c_{21}=c_{12},c_{11}=c_{22}=0\end{array}$$
  则根据贝叶斯分类器中的情况可以得到$\Lambda$和$\xi$,并对其进行取对数有:
$$\begin{array}{rl}\log \Lambda (x)& =-\frac{1}{2}(x-{\mu }_1{)}^T{C}^{-1}(x-{\mu }_1)+(x-{\mu }_2{)}^T{C}^{-1}(x-{\mu }_2)\\ & =({\mu }_1-{\mu }_2{)}^T{C}^{-1}x+\frac{1}{2}({\mu }_2^T{C}^{-1}{\mu }_2-{\mu }_1^T{C}^{-1}{\mu }_1)\\ & \log \xi =0\end{array}$$
  可以看到上述的表达式完全是一个线性的分类器的模型:
$$\begin{array}{rl}& y={\text{w}}^T\text{x}+b\\ & \text{w}=({\mu }_1-{\mu }_2{)}^T{C}^{-1}\\ & b=\frac{1}{2}({\mu }_2^T{C}^{-1}{\mu }_2-{\mu }_1^T{C}^{-1}{\mu }_1)\end{array}$$

3、总结

  需要注意的是虽然高斯环境下的贝叶斯分类器和感知器类似，但是二者不同：

1. 感知器对数据的要求是线性可分，否则决策边界将不断震荡；而高斯环境下的贝叶斯分类器本身就是假设二者有重叠且相关的；
2. 感知器是最小化分类误差概率，和最小化分类误差还是有区别的；
3. 感知器收敛算法是分参数的；
4. 感知器实现简单。

四、实验

  双月分类实验，目的是通过感知器对双月数据进行分类，实验分为两部分：第一部分为双月数据为线性可分的情况；第二部分为双月数据为线性不可分，非线性可分的情况：

1、线性可分moon

  如下图为线性可分的数据:

  下图为分类过程的损失和结果代码（中间的线为决策边界，即$wx+b=0$），可以看到损失函数下降的很快，基本很快就到0了：

  下面的几张图为感知调整的过程，可以看到调整的很快，第一个决策边界还不能完全拟合，第二个就基本定型了:   另外需要注意的是，设定的$b$和最后的决策边界关系很大，不同的$b$会有不同的边界，$b$不合适可能无法完全拟合，下图分别为不同$b$值的决策边界,三张图的$b$值分别为0.3,0.5,1.0:

2、线性不可分moon

  非线性数据:

  分类结果，可以看到孫然損失函數很快收斂但是後面還是在不斷震蕩:

五、附件

  git链接:perceptron
  双月数据生成代码:

# -*- coding: utf-8 -*-
#生成半月数据

import numpy as np
import matplotlib.pyplot as plt
 
 
def halfmoon(rad, width, d, n_samp): 
    '''生成半月数据
    @param  rad:    半径
    @param  width:  宽度
    @param  d:      距离
    @param  n_samp: 数量
    ''' 
    if n_samp%2 != 0:  
        n_samp += 1  
    
    data = np.zeros((3,n_samp))
      
    aa = np.random.random((2,int(n_samp/2)))  
    radius = (rad-width/2) + width*aa[0,:] 
    theta = np.pi*aa[1,:]        
      
    x     = radius*np.cos(theta)  
    y     = radius*np.sin(theta)  
    label = np.ones((1,len(x)))         # label for Class 1  
      
    x1    = radius*np.cos(-theta) + rad  
    y1    = radius*np.sin(-theta) - d  
    label1= -1*np.ones((1,len(x1)))     # label for Class 2  
     
    data[0,:]=np.concatenate([x,x1])
    data[1,:]=np.concatenate([y,y1])
    data[2,:]=np.concatenate([label,label1],axis=1)
    
    return data
 
def halfmoon_shuffle(rad, width, d, n_samp): 
     
    data = halfmoon(rad, width, d, n_samp)      
    shuffle_seq = np.random.permutation(np.arange(n_samp))  
    data_shuffle = data[:,shuffle_seq]
    
    return data_shuffle
 
 
if __name__ == "__main__":
    dataNum = 1000
    data = halfmoon(10,5,5,dataNum)
    pos_data = data[:,0: int(dataNum/2)]
    neg_data = data[:, int(dataNum/2):dataNum]
    
    np.savetxt('halfmoon.txt', data.T,fmt='%4f',delimiter=',')
    
    plt.figure()
    plt.scatter(pos_data[0,:],pos_data[1,:],c="b",s=10)
    plt.scatter(neg_data[0,:],neg_data[1,:],c="r",s=10)
    plt.savefig('./imgs/moon.png')
    plt.show()

  感知器分类实验代码:

#通过感知机分类半月数据
import numpy as np
import matplotlib.pyplot as plt

def sgn(y):
    y[y > 0] = 1
    y[y < 0] = -1
    return y

class Perceptron(object):
    '''单层感知机
    '''
    def __init__(self, shape):
        super(Perceptron, self).__init__()

        self.w = np.ones(shape)      #weigth
        self.b = 1.5                                 #the bias
        self.activate_func = sgn

    def update(self,x,y,out,learning_rate):
        self.w += learning_rate * x.T * (y - out)

    def calclate(self, x):
        return self.activate_func(np.dot(self.w, x.T) + self.b)

    def loss_func(self, pre_y, gt_y):
        return (pre_y - gt_y) ** 2

    def train(self, x, y, epochs, learning_rate):
        losses = []
        for epoch in range(epochs):
            loss_tmp = []
            for i in range(x.shape[0]):
                out = self.calclate(x[i])
                loss_tmp.append(self.loss_func(out, y[i]))
                self.update(x[i], y[i], out, learning_rate)

            losses.append(sum(loss_tmp)/len(loss_tmp))
        return losses

    def predict(self, x):
        out = self.calclate(x)
        return out
    
    def test(self, x,y):
        label = self.predict(x)
        gt_count = np.sum(label==y)
        wrong_count = np.sum(label!=y)
        return wrong_count/(wrong_count+gt_count),gt_count/(wrong_count+gt_count)


    def get_params(self):
        return {'weight':self.w, 'bias':self.b}

    def draw(self):
        axis = [i for i in range(1000)]
        out = [self.w * i + self.b for i in axis]
        
        plt.plot(axis, out)
        plt.show()

def load_data(file):
    x = []
    y = []
    with open(file, 'r') as f:
        lines = f.readlines()
        for line in lines:
            line = line.strip().split(',')
            
            x_item = [float(line[0]), float(line[1])]
            y_item = float(line[2])
            
            x.append(x_item)
            y.append(y_item)
    
    return np.array(x), np.array(y)


def split_data(x, y):
    train_x, test_x = x[:int(x.shape[0]*0.7)], x[int(x.shape[0]*0.7):]
    train_y, test_y = y[:int(y.shape[0]*0.7)], y[int(y.shape[0]*0.7):]
    
    return train_x, train_y, test_x, test_y

if __name__ == '__main__':
    #进行非线性数据的分类实验时，只需要将数据的间隔缩小保证二者重合即可
    desc = 'nonlinear'
    file = './halfmoon.txt'
    x,y = load_data(file)

    train_x, train_y, test_x, test_y = split_data(x, y)

    neur = Perceptron((1,2))
    losses = neur.train(train_x,train_y,100, 0.0001)
    
    err,acc = neur.test(test_x, test_y)
    print('rate of error:', err)
    print('rate of accuracy:', acc)


    #画损失曲线
    axis = [i for i in range(len(losses))]
    plt.figure()
    plt.plot(axis, losses)
    plt.savefig('../imgs/%s_mse_loss.png' % desc)
    #plt.show()

    #画决策面   
    x_aixs = x[:,0]
    y_aixs = x[:,1]

    neg_x_axis = x_aixs[y==-1]
    neg_y_axis = y_aixs[y==-1]
    
    pos_x_axis = x_aixs[y==1]
    pos_y_axis = y_aixs[y==1]

    #感知机的参数
    params = neur.get_params()
    w = params['weight']
    b = params['bias']

    k = -1 * w[0][0] / w[0][1]
    b = -1 * b / w[0][1]

    divid_x = [i for i in range(-15,25)]
    divid_y = [k * i + b for i in divid_x]

    plt.figure()
    plt.plot(divid_x, divid_y, c='r')
    plt.scatter(neg_x_axis,neg_y_axis,c="b",s=10)
    plt.scatter(pos_x_axis,pos_y_axis,c="g",s=10)
    plt.savefig('../imgs/%s_divide.png' % desc)   #保存决策面