感知器(perceptron)模型分析及实现

\qquad 感知器 $(perceptron)$ 本质上是一个线性模型，可以实现“线性分类”。

1. 感知器模型

\qquad 假设输入样本 $\mathbf{x}=[x_1,x_2,\cdots ,x_m{]}^T\in R^m$，感知器实现线性分类的效果主要取决于权值 $\mathbf{w}=[w_1,w_2,\cdots ,w_m{]}^T$ 和偏置 $b$ 的大小。

\qquad 感知器包含一个线性组合器$(linearcombiner)$和激活过程$(activation)$，其结构如图 $1$ 所示：
\qquad

图1　From Fig 1.1 《Neural Networks and Learning Machines》

\qquad 显然，由图 $1$ 可以得到：

$(1)$ 线性组合器的输出：$v={\mathbf{w}}^T\mathbf{x}+b$

$(2)$ 感知器的输出是对线性组合器的输出进行激活的结果：$y=\phi (v)$

\qquad 常用的激活函数$(activationfunction)$ 可以是符号函数 $sgn(\cdot )$，本文采用的是：

$y=\phi (v)=\{\begin{array}{cc}1& ,{\mathbf{w}}^T\mathbf{x}+b>0\\ & \\ 0& ,{\mathbf{w}}^T\mathbf{x}+b\le 0\end{array}$

\qquad 一般地，为了更好地表示线性模型，将感知器模型描述为图 $2$ 中的表示：
\qquad

图2　From Fig 1.3 《Neural Networks and Learning Machines》

\qquad 如图 $2$ 所示，将感知器模型中的偏置 $b$ 也看作是一个权值 $w_0$，那么：

$\hat{\mathbf{w}}=[b,{\mathbf{w}}^T{]}^T=[w_0,w_1,w_2,\cdots ,w_m{]}^T$，$w_0=b$

\qquad 为了便于用向量表示线性模型，将训练样本 $\mathbf{x}=[x_1,x_2,\cdots ,x_m{]}^T$ 进行扩展：

$\hat{\mathbf{x}}=[1,{\mathbf{x}}^T{]}^T=[1,x_1,x_2,\cdots ,x_m{]}^T$，$x_0=1$

\qquad 因此，图 $2$ 中的感知器模型可以表示为：

$(1)$ 线性组合器的输出：

$v={\mathbf{w}}^T\mathbf{x}+b={\hat{\mathbf{w}}}^T\hat{\mathbf{x}}$

$(2)$ 感知器的输出：

$y=\phi (v)=\{\begin{array}{cc}1& ,{\hat{\mathbf{w}}}^T\hat{\mathbf{x}}>0\\ & \\ 0& ,{\hat{\mathbf{w}}}^T\hat{\mathbf{x}}\le 0\end{array}$

【注】为了方便表示，本文后续部分直接使用 $\mathbf{x}$ 代替 $\hat{\mathbf{x}}$，用 $\mathbf{w}$ 代替 $\hat{\mathbf{w}}$

\qquad

2. 几何意义

• 线性可分的情况——图 $3(a)$

\qquad 以输入样本 $\mathbf{x}=[x_1,x_2{]}^T\in R^2$ 为例，在图 $3(a)$ 中有 $4$ 个训练样本：${\mathbf{x}}_1=[0,0{]}^T,{\mathbf{x}}_2=[1,0{]}^T,{\mathbf{x}}_3=[1,1{]}^T,{\mathbf{x}}_4=[0,1{]}^T$，其中 ${\mathbf{x}}_1\in {\ell }_1$，其余样本属于 ${\ell }_2$。

\qquad 感知器的参数 $\mathbf{w}=[b,w_1,w_2{]}^T$ 实际上是在 $R^2$ 中确定了一条直线，如图 $3(a)$ 所示，能够将正例和负例进行区分的直线并不只有一种选择。
\qquad

图3 感知器模型的几何意义（线性可分、线性不可分）

• 线性不可分的情况——图 $3(b),(c)$ “异或”问题

\qquad 异或问题无法使用 $1$ 条直线（分类面）来实现，或者在图 $3(b)$ 中使用 $2$ 条直线来区分，或者使用图 $3(c)$ 中的不规则分类面。

\qquad 图 $3(b)$ 中使用 $2$ 条直线实现对数据集的分类，实际上就是采用多层感知器$(multilayerperceptron,MLP)$ 的结构来实现。

\qquad

3. 感知器模型的训练

\qquad 感知器的训练过程，就是为了确定模型的参数 $\{b,w_1,w_2,\cdots ,w_m\}$。以图 $4$ 为例，也就是为了确定 $R^2$ 中的某条直线的参数 $\{b,w_1,w_2\}$。
\qquad

图4 感知器的作用是，确定 $R^2$ 中的分界面（直线）将 ${\ell }_1$ 和 ${\ell }_2$ 分隔开

\qquad 线性组合器的输出：　　　　　$v={\mathbf{w}}^T\mathbf{x}$

\qquad 感知器的（实际）输出值：　　$y=\phi (v)=\{\begin{array}{ccc}1& ,{\mathbf{w}}^T\mathbf{x}>0& ⟹\mathbf{x}\in {\ell }_1\\ & & \\ 0& ,{\mathbf{w}}^T\mathbf{x}\le 0& ⟹\mathbf{x}\in {\ell }_2\end{array}$

\qquad 考虑训练样本集：

$\{{\mathbf{x}}_n,t_n\}{|}_{n=1}^N,{\mathbf{x}}_n\in R^m$，其中 $t_n\in \{0,1\}$ 为（期望输出的）目标值

\qquad\qquad 对于训练样本 ${\mathbf{x}}_n$，其目标值 $t_n=\{\begin{array}{cc}1& ,{\mathbf{x}}_n\in {\ell }_1\\ & \\ 0& ,{\mathbf{x}}_n\in {\ell }_2\end{array}$

\qquad
\qquad 训练规则基于“误差修正学习”：

${\mathbf{w}}^{new}={\mathbf{w}}^{old}-\eta (y_n-t_n){\mathbf{x}}_n$，　其中 $\eta$ 为学习率

（1）若感知器的输出值 $y_n$ 与目标值 $t_n$ 一致时，说明分类面正确区分了当前的训练样本，不需要改变当前分类面，无需调整权值， ${\mathbf{w}}^{new}={\mathbf{w}}^{old}$
（2）若感知器的输出值 $y_n$ 与目标值 $t_n$ 不一致，说明分类面错误区分了当前的训练样本，需要调整权值的大小，来改变分类面的方向，使得当前样本 ${\mathbf{x}}_n$ 能够被正确划分

\qquad 考虑具体样本时的“误差修正学习”规则：

• 当训练样本 ${\mathbf{x}}_n\in {\ell }_1(t_n=1)$ 被送入感知器

$⟶$　若输出值 $y_n=1$（判定 ${\mathbf{x}}_n\in {\ell }_1$，无误差），权值不会发生改变 ${\mathbf{w}}^{new}={\mathbf{w}}^{old}$
$⟶$　若输出值 $y_n=0$（判定 ${\mathbf{x}}_n\in {\ell }_2$，有误差），权值更新为 ${\mathbf{w}}^{new}={\mathbf{w}}^{old}+\eta {\mathbf{x}}_n$
\qquad

图5 权值更新公式 ${\mathbf{w}}^{new}={\mathbf{w}}^{old}+\eta {\mathbf{x}}_n$ 中取 $“+”$ 号的解释【当训练样本 ${\mathbf{x}}_n$ 被错误划分】
（1）当训练样本 ${\mathbf{x}}_n\in {\ell }_1$ 被(旧的)蓝色分类面错误划分，取 $“+”$ 号调整权值，才能让旧的分类面旋转到能够正确划分 ${\mathbf{x}}_n$ 的红色分类面的方向
（2）训练过程中，学习率 $\eta$ 决定了权值变化的幅度（图中为 $\eta =1$）
（3）已经正确划分的样本不会改变权值，训练过程只会针对图中 ${\mathbf{x}}_n$ 样本，通过一步步调整 $\eta {\mathbf{x}}_n$（蓝色虚线向量） 来实现正确划分

• 当训练样本 ${\mathbf{x}}_n\in {\ell }_2(t_n=0)$ 被送入感知器

$⟶$　若输出值 $y_n=0$（判定 ${\mathbf{x}}_n\in {\ell }_2$，无误差），权值不会发生改变 ${\mathbf{w}}^{new}={\mathbf{w}}^{old}$
$⟶$　若输出值 $y_n=1$（判定 ${\mathbf{x}}_n\in {\ell }_1$，有误差），权值更新为 ${\mathbf{w}}^{new}={\mathbf{w}}^{old}-\eta {\mathbf{x}}_n$
\qquad

图6 权值更新公式 ${\mathbf{w}}^{new}={\mathbf{w}}^{old}-\eta {\mathbf{x}}_n$ 中取 $“+”$ 号的解释【当训练样本 ${\mathbf{x}}_n$ 被错误划分】
（1）当训练样本 ${\mathbf{x}}_n\in {\ell }_2$ 被(旧的)蓝色分类面错误划分，取 $“-”$ 号调整权值，才能让旧的分类面旋转到能够正确划分 ${\mathbf{x}}_n$ 的红色分类面的方向
（2）训练过程中，学习率 $\eta$ 决定了权值变化的幅度（图中为 $\eta =1$）
（3）已经正确划分的样本不会改变权值，训练过程只会针对图中 ${\mathbf{x}}_n$ 样本，通过一步步调整 $\eta {\mathbf{x}}_n$（蓝色虚线向量） 来实现正确划分

\qquad

4. 批处理训练过程

4.1 训练数据的规范化

\qquad 由图 $4$，假设分类面 ${\mathbf{w}}^T\mathbf{x}+b=0$ 可以实现正确的分类。那么对于训练样本 ${\mathbf{x}}_n$ 而言，如果 ${\mathbf{w}}^T{\mathbf{x}}_n>0$，则 ${\mathbf{x}}_n\in {\ell }_1$，如果 ${\mathbf{w}}^T{\mathbf{x}}_n<0$，则 ${\mathbf{x}}_n\in {\ell }_2$。
\qquad

图7 训练数据的规范化过程【取自《模式分类》Fig 5.8】
图 (a) 为原始训练数据，黑色训练样本满足 ${\mathbf{w}}^T{\mathbf{x}}_1>0$，红色训练样本满足 ${\mathbf{w}}^T{\mathbf{x}}_2<0$
图 (b) 为规范化后的数据，红色点取反后，满足 ${\mathbf{w}}^T(-{\mathbf{x}}_2)>0$

\qquad 训练数据的规范化 $(normalization)$ 操作可以简化训练过程的描述：
\qquad （1）考虑 $\mathbf{x}\in {\ell }_1$ 类中训练数据满足 ${\mathbf{w}}^T\mathbf{x}>0$
\qquad （2）将 $\mathbf{x}\in {\ell }_2$ 类中训练数据取反：${\mathbf{w}}^T\mathbf{x}<0⟹{\mathbf{w}}^T(-\mathbf{x})>0$
\qquad （3）此时，寻找权向量 $\mathbf{w}$ 只需要针对新的数据集 $\mathbf{\ell }={\ell }_1\cup \{-{\ell }_2\}$ ，计算 ${\mathbf{w}}^T\mathbf{x}>0,\mathbf{x}\in \mathbf{\ell }$ 即可。
\qquad

4.2 批处理感知器算法

\qquad 定义感知器代价函数：

$J(\mathbf{w})=\sum _{\mathbf{x}\in \mathcal{X}}(-{\mathbf{w}}^T\mathbf{x})$

\qquad 其中，$\mathcal{X}$ 表示被错误划分的训练样本集。

\qquad 若 $\mathbf{x}\in {\ell }_1$ 被错分，那么 ${\mathbf{w}}^T\mathbf{x}<0$；若 $\mathbf{x}\in {\ell }_2$ 被错分，那么 ${\mathbf{w}}^T(-\mathbf{x})<0$ 。因此，选择 ${\sum }_{\mathbf{x}\in \mathcal{X}}(-{\mathbf{w}}^T\mathbf{x})$ 作为代价函数，被错分的训练样本越多，代价函数的值就越大。

\qquad 如果 $\mathcal{X}$ 为空集，则表明所有训练样本都被正确分类，代价函数的值就越小。

\qquad 采用梯度下降法求解：

$\nabla J(\mathbf{w})=\frac{\partial J(\mathbf{w})}{\partial \mathbf{w}}=\sum _{\mathbf{x}\in \mathcal{X}}(-\mathbf{x})$

${\mathbf{w}}^{new}={\mathbf{w}}^{old}-\eta \nabla J(\mathbf{w})$

\qquad 因此，迭代公式为：

${\mathbf{w}}^{new}={\mathbf{w}}^{old}+\eta \sum _{\mathbf{x}\in \mathcal{X}}\mathbf{x}$

\qquad

实现代码

import numpy as np
import matplotlib.pyplot as plt

def singleperceptron(xhat,target,eta,mode='seq'):       
    iteration = 0
    flag = 1
    if mode=='seq':
        weight = np.random.random(xhat.shape[1])
        y = np.zeros((len(xhat),1)) 
        while flag:                
            # sequential
            for i in range(len(xhat)):
                tmp = np.dot(weight,xhat[i,:])
                if tmp > 0:
                    y[i] = 1
                else:
                    y[i] = 0                          
                weight = weight - eta*(y[i]-target[i])*xhat[i,:]               
            print(weight)  
            iteration = iteration + 1
            if np.sum(np.abs(y-target))==0:#此处的迭代终止条件只针对线性可分数据
                flag = 0    
            
    if mode=='batch':
        weight = np.random.random((xhat.shape[1],1))
        xhat1 = xhat*np.where(target>0,1,-1)
        print(weight.flatten())
        while flag:             
            # batch
            y1 = np.dot(xhat,weight)
            y1 = np.where(y1>0,1,0)
            t = np.dot(xhat1.T, np.abs(y1-target))
            weight += eta*t
            print(weight.flatten())         
            iteration = iteration + 1   
            if np.sum(t)==0:#此处的迭代终止条件只针对线性可分数据
                flag = 0
        weight = weight.flatten()/np.sum(weight)       
    
    return weight

def gen_lineardata(weight,interval):
    y = -(weight[0]*interval + weight[2])/weight[1]
    return y

def halfmoon(rad, width, dist, n_samp):      
    if n_samp%2 != 0:  
        n_samp += 1      
    data = np.zeros((3,n_samp))      
    rd = np.random.random((2,n_samp//2))  
    radius = (rad-width//2) + width*rd[0,:] 
    theta = np.pi*rd[1,:]          
    x1     = radius*np.cos(theta)  
    y1     = radius*np.sin(theta) + dist/2  
    label1 = np.ones((1,len(x1)))           # label= 1 for Class 1        
    x2    = radius*np.cos(-theta) + rad  
    y2    = radius*np.sin(-theta) - dist/2  
    label2= np.zeros((1,len(x2)))           # label= 0 for Class 2       
    data[0,:]=np.concatenate([x1,x2])
    data[1,:]=np.concatenate([y1,y2])
    data[2,:]=np.concatenate([label1,label2],axis=1)    
    shuffle_seq = np.random.permutation(np.arange(n_samp))  
    data_shuffle = data[:,shuffle_seq]
    return data,data_shuffle  

if __name__ == "__main__":
    # dataset1: halfmoon
    tnum = 8000    
    data,data_shuffle = halfmoon(20,15,3,tnum)
    pos_data = data[:,0:tnum//2]
    neg_data = data[:,tnum//2:tnum]  
    training_data = data_shuffle.T
    tmp1 = training_data[0:tnum,0:2]
    tmp2 = np.ones((tnum,1))
    xhat = np.concatenate((tmp1,tmp2),axis=1)
    target = training_data[0:tnum,2:]    
    interval = np.linspace(-30,50,100) 
       
    # dataset2: or
    # data = np.array([[0,0],[0,1],[1,1],[1,0]])
    # pos_data = data[0:1,:].T
    # neg_data = data[1:,:].T
    # target = np.array([1,0,0,0]).reshape(4,1)
    # xhat = np.concatenate((data,np.ones((4,1))),axis=1)
    # interval = np.linspace(-0.2,0.6,100)
    
    # main
    weight = singleperceptron(xhat,target,0.2)
    print('sequential:',weight)    
    y = gen_lineardata(weight,interval)
    plt.figure(1)    
    plt.plot(interval,y,'k')       
    plt.plot(pos_data[0,:],pos_data[1,:],'bo',markerSize=1)
    plt.plot(neg_data[0,:],neg_data[1,:],'ro',markerSize=1)        
    plt.title('sequential')    
    
    weight = singleperceptron(xhat,target,0.2,'batch')
    print('batch:',weight)    
    y = gen_lineardata(weight,interval)
    plt.figure(2)    
    plt.plot(interval,y,'k')       
    plt.plot(pos_data[0,:],pos_data[1,:],'bo',markerSize=1)
    plt.plot(neg_data[0,:],neg_data[1,:],'ro',markerSize=1)  
    plt.title('batch')  
    plt.show()

某一次运行结果
（1）半月形数据
sequential模式：$[w_1,w_2,b]=$ [0.01727369 5.59047961 0.9740486 ]
batch模式：　　$[w_1,w_2,b]=$ [-0.06142 1.06444655 -0.00302655]

（2）OR数据：
sequential模式：$[w_1,w_2,b]=$ [-0.22742997 -0.31955376 0.1226006 ]
batch模式：　　$[w_1,w_2,b]=$ [ 0.53262345 0.62096392 -0.15358737]
（3）线性不可分数据