统计学习方法(2)——感知机原始形式、对偶形式及Python实现

感知机作为一种最简单的线性二分类模型，可以在输入空间（特征空间）将实例划分为正负两类。本文主要介绍感知机两种形式对应的学习算法及Python实现。

---

　感知机学习算法的原始形式

对于输入空间，感知机通过以下函数将其映射至{+1，-1}的输出空间

$$f(x) = sign(w \cdot x + b)$$ (1)
对于所有的错分类点 $i \in M$，都有 $- {y_i}(w \cdot {x_i} + b) > 0$,因此我们可以定义如下的损失函数作为优化准则：
$$L(w,b) = - \sum\limits_{{x_i} \in M} {{y_i}(w \cdot {x_i} + b)}$$ (2)
通过求解损失函数(2)的梯度(3)，
$$\begin{array}{l} {\nabla _w}L(w,b) = - \sum\limits_{{x_i} \in M} {{y_i}{x_i}} \\ {\nabla _b}L(w,b) = - \sum\limits_{{x_i} \in M} {{y_i}} \end{array}$$ (3)
我们很容易就可以得到感知机学习算法的原始形式.
$$\begin{array}{l} w \leftarrow w + \eta {y_i}{x_i}\\ b \leftarrow b + \eta {y_i} \end{array}$$ (4)
整个算法流程如下：

1. 选取初值w0,b0
2. 在训练集中任意选取点(xi,yi)
3. 如果$- {y_i}(w \cdot {x_i} + b) > 0$则按照(4)式更新w,b
4. 重复2直到没有被误分的点

以上即为感知机算法的原始形式，理解起来比较简单，也较容易实现。下面给出其的Python实现

from __future__ import division
import random
import numpy as np
import matplotlib.pyplot as plt  


def sign(v):
    if v>=0:
        return 1
    else:
        return -1

def train(train_num,train_datas,lr):
    w=[0,0]
    b=0
    for i in range(train_num):
        x=random.choice(train_datas)
        x1,x2,y=x
        if(y*sign((w[0]*x1+w[1]*x2+b))<=0):
            w[0]+=lr*y*x1
            w[1]+=lr*y*x2
            b+=lr*y
    return w,b
def plot_points(train_datas,w,b):
    plt.figure()
    x1 = np.linspace(0, 8, 100)  
    x2 = (-b-w[0]*x1)/w[1]
    plt.plot(x1, x2, color='r', label='y1 data')
    datas_len=len(train_datas)
    for i in range(datas_len):
        if(train_datas[i][-1]==1):
            plt.scatter(train_datas[i][0],train_datas[i][1],s=50)  
        else:
            plt.scatter(train_datas[i][0],train_datas[i][1],marker='x',s=50)  
    plt.show()


if __name__=='__main__':
    train_data1 = [[1, 3, 1], [2, 2, 1], [3, 8, 1], [2, 6, 1]]  # 正样本
    train_data2 = [[2, 1, -1], [4, 1, -1], [6, 2, -1], [7, 3, -1]]  # 负样本
    train_datas = train_data1 + train_data2  # 样本集
    w,b=train(train_num=50,train_datas=train_datas,lr=0.01)
    plot_points(train_datas,w,b)

可以看出正负样本被红线分到了两个区域。

感知机学习算法的对偶形式

相比于原始形式，其对偶形式在理解上没有前者那么直观，网上关于其实现代码的例子也比较少。
在《统计学习方法》一书中，关于对偶形式有如下的描述：

对偶形式的基本想法是，将w和b表示为实例${x_i}$ 和标记 ${y_i}$ 的线性组合的形式，通过求解其系数而求得w和b.

假设w0=0,b=0,那么从(4)式可以看出，当所有的点均不发生误判时，最后的w,b一定有如下的形式:

$$\begin{array}{l} w = \sum\limits_{i = 1}^N {{n_i}\eta {y_i}{x_i}} = \sum\limits_{i = 1}^N {{\alpha _i}} {y_i}{x_i}\\ b = \sum\limits_{i = 1}^N {{n_i}\eta {y_i}} = \sum\limits_{i = 1}^N {{\alpha _i}} {y_i} \end{array}$$
(5)
其中 $\alpha_i=n_i\eta$中 $n_i$代表对第i个样本的学习次数，感知机对偶形式的完整形式即为(6)式：
$$f(x) = sign(\sum\limits_{j = 1}^N {{\alpha _j}} {y_j}{x_j} \cdot x + b)$$ (6)

1. 初始化$\alpha=0$,$b=0$.
2. 任意选取(xi,yi)
3. 如果$y_i(\sum\limits_{j = 1}^N {{\alpha _j}} {y_j}{x_j} \cdot x_i + b)\le0$,即发生误判，则对$\alpha_i,b$进行更新：
   $$\begin{array}{1} \alpha_i\leftarrow \alpha_i+\eta\\ b_i\leftarrow b_i+\eta y_i \end{array}$$
4. 重复2直到所有点都被正确分类

简而言之，感知机的对偶形式就是把对$w,b$的学习变成了对$\alpha,b$的学习，原始形式中，$w$在每一轮迭代错分时都需要更新，而采用对偶形式时，对于某一点(xi,yi)发生错分时，我们只需要更新其对应的$\alpha_i$即可，最后按照(5)式即可一次计算出$w$.
同时我们上述步骤3中的$y_i(\sum\limits_{j = 1}^N {{\alpha _j}} {y_j}{x_j} \cdot x_i + b)\le0$可以看出，$x_j \cdot x_i$仅以内积的形式出现，因此我们可以是先计算出x的gram矩阵存储起来，这样正式训练时只需要查表就可以得到$x_j \cdot x_i$的值，这样做可以方便程序的优化，提高运算的速度。
原始形式和对偶形式对参数b的处理是相同的。
以下是感知机对偶形式的Python实现

from __future__ import division
import random
import numpy as np
import matplotlib.pyplot as plt  


def sign(v):
    if v>=0:
        return 1
    else:
        return -1

def train(train_num,train_datas,lr):
    w=0.0
    b=0
    datas_len = len(train_datas)
    alpha = [0 for i in range(datas_len)]
    train_array = np.array(train_datas)
    gram = np.matmul(train_array[:,0:-1] , train_array[:,0:-1].T)
    for idx in range(train_num):
        tmp=0
        i = random.randint(0,datas_len-1)
        yi=train_array[i,-1]
        for j in range(datas_len):
            tmp+=alpha[j]*train_array[j,-1]*gram[i,j]
        tmp+=b
        if(yi*tmp<=0):
            alpha[i]=alpha[i]+lr
            b=b+lr*yi
    for i in range(datas_len):
        w+=alpha[i]*train_array[i,0:-1]*train_array[i,-1]
    return w,b,alpha,gram

def plot_points(train_datas,w,b):
    plt.figure()
    x1 = np.linspace(0, 8, 100)
    x2 = (-b-w[0]*x1)/(w[1]+1e-10)
    plt.plot(x1, x2, color='r', label='y1 data')
    datas_len=len(train_datas)
    for i in range(datas_len):
        if(train_datas[i][-1]==1):
            plt.scatter(train_datas[i][0],train_datas[i][1],s=50)  
        else:
            plt.scatter(train_datas[i][0],train_datas[i][1],marker='x',s=50)  
    plt.show()

if __name__=='__main__':
    train_data1 = [[1, 3, 1], [2, 2, 1], [3, 8, 1], [2, 6, 1]]  # 正样本
    train_data2 = [[2, 1, -1], [4, 1, -1], [6, 2, -1], [7, 3, -1]]  # 负样本
    train_datas = train_data1 + train_data2  # 样本集
    w,b,alpha,gram=train(train_num=500,train_datas=train_datas,lr=0.01)
    plot_points(train_datas,w,b)