感知机原理与python实现

感知机原理与python实例

原理

线性可分

给定一个二类数据集的标签为正负1，如果存在某个超平面$S$：
$$wx+b=0$$
将所有正负实例点完全正确地划分到超平面的两侧，即对$y=+1$的实例有：$wx+b>0$；即对$y=-1$的实例有：$wx+b<0$.

判别函数

针对标签为正负1的二分类问题，感知机的判别函数为：
$$f(x)=sign(wx+b)$$

损失函数

自然地想，损失函数应当是误分类的点的个数，但是这个函数是不可导的，所以优化起来比较困难。

考虑$R^n$空间中的任意一点$x_0$到超平面的距离为：
$$\frac{1}{||w|{|}_2}(w{x}_0+b)$$
对应误分类集合$M$中的点来说：
$$-\frac{y}{||w|{|}_2}(wx+b)>0$$
所以最终选择的损失函数为：
$$L(w,b)=-\sum _{x\in M}y(wx+b)$$

学习过程

目前学习的过程就变成使损失函数最小化的过程。
$$\begin{array}{rl}(w,b)& =\arg \underset{w,b}{\min }L(w,b)\\ \frac{\partial L}{\partial w}& =-\sum _{x\in M}yx\\ \frac{\partial L}{\partial b}& =-\sum _{x\in M}y\end{array}$$
通过梯度下降的方式，在每次迭代过程中以学习率$\eta$更新$w,b$的值，直到结果收敛或者达到指定的迭代次数为止。
$$\begin{gathered} w^t=w^{t-1}-\eta \frac{\partial L}{\partial w} \\ {b}^t=b^{t-1}-\eta \frac{\partial L}{\partial b} \end{gathered}$$

收敛性证明

下面证明当数据是线性可分的情况下，感知机准则是一定收敛的。通过两种方法来进行证明。

方式一

方便起见，令$a=(w^T,b{)}^T,z=(x^T,1{)}^T$。
设最优的权重解为：$\hat{a}$，一定满足$\forall x_i,{\hat{a}}^{T}z{y}_i>0$。
假设经过$t$轮迭代之后的解为：$a^t$，在这一轮中仍然被分错的向量集合为：$E(t)=\{z|a^{T}zy<0\}$，根据上文描述的梯度下降的规则，在第$t+1$轮中，权重应当被更新为：
$$a^{(t+1)}=a^t+\sum _{x_i\in E(t)}{y}_i{z}_i$$
令
$$\sum _{x_i\in E(t)}{y}_i{a^t}^T{z}_i=e(t)<0$$

Proof:

$$\begin{array}{rl}||a^{(t+1)}-\alpha \hat{a}|{|}^2& =||a^t+\sum _{x_i\in E(t)}{y}_i{z}_i-\alpha \hat{a}|{|}^2\\ & =||a^t-\alpha \hat{a}|{|}^2+2(a^t-\alpha \hat{a}{)}^T\sum _{x_i\in E(t)}{y}_i{z}_i+||\sum _{x_i\in E(t)}{y}_i{z}_i|{|}^2\\ & =||a^t-\alpha \hat{a}|{|}^2+2e(t)-2\alpha {\hat{a}}^T\sum _{x_i\in E(t)}{y}_i{z}_i+||\sum _{x_i\in E(t)}{y}_i{z}_i|{|}^2\\ & \le ||a^t-\alpha \hat{a}|{|}^2-2\alpha {\hat{a}}^T\sum _{x_i\in E(t)}{y}_i{z}_i+||\sum _{x_i\in E(t)}{y}_i{z}_i|{|}^2(\star )\\ D& =\sum _{x_i\in E(t)}||y_i{z}_i||\ge \sum _{x_i\in E(t)}||y_i{z}_i||\ge ||\sum _{x_i\in E(t)}{y}_i{z}_i||\\ \rho & =\underset{i}{\min }{y}_i{\hat{a}}^T{z}_i\\ let\alpha & =\frac{D^2}{\rho }\\ (\star )& \le ||a^t-\alpha \hat{a}|{|}^2-2\alpha \rho +D^2\\ & =||a^t-\alpha \hat{a}|{|}^2-D^2\\ & \le ||a^0-\alpha \hat{a}|{|}^2-(t+1)D^2\\ so\exists \hat{t}s.t.a^{\hat{t}}& =\alpha \hat{a}\end{array}$$
收敛性证毕。

方式二（Novikoff定理）

设训练集$T=\{(x_1,y_1),...,(x_N,y_N)\}$是线性可分的，设$y_i\in \{+1,-1\},i=1,2,...,N$，则

1. 存在满足条件$||\widehat{w_{opt}}=1||$的超平面$\widehat{w_{opt}}\cdot \hat{x}=w_{opt}\cdot x+b_{opt}$将训练集完全分开；且存在$\gamma >0$满足：
   $$y_i(\widehat{w_{opt}}\cdot \hat{x})\ge \gamma ,\forall i$$
2. 令$R={\max }_{1\le i\le N}||\widehat{x_i}||$，则感知机算法在训练数据机上的误分类次数$k$满足不等式：
   $$k\le (\frac{R}{\gamma }{)}^2$$

Proof:

1. 因为线性可分，所以：
   $$y_i(\widehat{w_{opt}}\cdot \hat{x})>0$$
   令
   $$\gamma =\underset{i}{\min }{y}_i(\widehat{w_{opt}}\cdot \hat{x})$$
   即可
2. 由梯度下降的权值更新方式可知：
   $$\widehat{w_k}={\hat{w}}_{k-1}+\eta y_i{x}_i$$
   在这里我们每出现一个误分类的数据就进行一次权值更新， $w_k$指出现第$k$个误分类的错误时候更新得到的权重，假定初始权重$w_0$为$0$.
   则有
   $$\begin{array}{rl}\widehat{w_k}\cdot {\hat{w}}_{opt}& \ge {\hat{w}}_{k-1}\cdot {\hat{w}}_{opt}+\eta \gamma \\ & \ge {\hat{w}}_{k-2}\cdot {\hat{w}}_{opt}+2\eta \gamma \\ & \cdots \\ & \ge {\hat{w}}_0\cdot {\hat{w}}_{opt}+k\eta \gamma \\ & =k\eta \gamma (1)\end{array}$$
   另有
   $$\begin{array}{rl}||\widehat{w_k}|{|}^2& =||{\hat{w}}_{k-1}+\eta y_i{x}_i|{|}^2\\ & =||{\hat{w}}_{k-1}|{|}^2+2\eta y_i{{\hat{w}}_{k-1}}^T{x}_i+||\eta y_i{x}_i|{|}^2\\ & \le ||{\hat{w}}_{k-1}|{|}^2+{\eta }^2{R}^2\\ & \cdots \\ & \le ||{\hat{w}}_0|{|}^2+k{\eta }^2{R}^2\\ & =k{\eta }^2{R}^2(2)\end{array}$$
   结合$(1)(2)$得到：
   $$\begin{array}{rl}k\eta \gamma \le \widehat{w_k}\cdot {\hat{w}}_{opt}& \le ||\widehat{w_k}||\cdot ||{\hat{w}}_{opt}||\le \sqrt{k}\eta R\\ k& \le {(\frac{R}{\gamma })}^2\end{array}$$
   故感知机一定在有限步内收敛。

对偶形式

感知机的对偶形式为
$$f(x)=sign(\sum _{j=1}^N{\alpha }_j{y}_j{x}_j\cdot x+\sum _{i=1}^N{\alpha }_i{y}_i)$$
可以发现只是权值的变化了一种形式，这一点可以直接从梯度下降的递推公式中看出来。（默认初始权值都是1）。需要说明的是${\alpha }_i$表示的是第$i$个数据在整个过程中被分错的次数。

对应的学习过程也就变成了改变$\alpha$的过程，每当出现一个数据被分错了，就${\alpha }_i={\alpha }_i+\eta$直到收敛为止。

另外还有一点就是整个训练的过程对于数据本身仅以内积的形式出现，可以预先计算好内积的矩阵，即Gram矩阵：
$$G=[x_i\cdot x_j{]}_{N\times N}$$

实例

首先生成一组线性可分的数据，如下图所示：

然后将数据转化为numpy中的array形式，并且设置标签为$\{-1,+1\}$，初始化权重都是$0$.

data = np.vstack([data0, data1])
label = np.hstack([np.ones(data0.shape[0]) * -1.0, np.ones(data1.shape[0])]).reshape(len(data), 1)
data = np.c_[data, np.ones(len(data))]

随后是算法的主体——梯度下降。在梯度下降的过程中，碰到的最大的困难就是梯度过大，导致整个算法不停的抖动，在这里很简单地降低学习率，其实应用随即梯度下降等优化算法可能会更好一些。

w = np.array([0.0, 0.0, 0.0]).reshape(1, 3)
error = 1
epoch = 0
learning_rate = 0.000001
while error != 0.0:
    res = np.multiply(np.dot(w, data.T), label.T)[0]
    print(res)
    error = 0
    epoch = epoch + 1
    for i in range(len(res)):
        x = -data[i] * label[i]
        if res[i] <= 1e-3:
            w = w - learning_rate * x
            error = error + 1
    print("Error rate in epoch {} is {:.2f}%".format(epoch, error / len(data) * 100))

总共迭代了2651轮才最终收敛，最终的权值情况为：

[ 0.00027111  0.00135846 -0.091094  ]

最终分类的效果如下图所示：

参考资料

[1] 李航 《统计学习方法》 第2章