李航机器学习方法3之感知机

0.参考

机器学习方法，作者：李航
感知机与超平面，作者：GRNovmbrain
浅析感知机（一）–模型与学习策略，作者：忆臻

1.待解决问题

1.$w^{T}x+b=0中w^T为什么是约束边界的法向量？$
2.$从点到超平面的距离推导出lossfunction。$

也就是需要首先找到损失函数，然后转化为最优化问题。

1.1需要知道的是

思想：错误驱动
感知机解决的是二分类问题且必须线性可分，输入（特征向量）$x\in {\mathbb{R}}^p$，输出 y = { − 1 , + 1 } y=\{-1,+1\} y={−1,+1}
决策函数：$f(x)=sign(w^{T}x+b)$
$sign(a)=\{\begin{array}{l}-1,a<0\\ +1,a\ge 0\end{array}$
其中$w$是weight vector，$b$是bias

图示：

1.2补充：什么是线性可分？

给定一个数据集，如果存在某个超平面$S(wx+b=0)$，能够将数据集的正实例点和负实例点完全正确的划分到超平面的两侧，即对$y=+1$的实例点，有$wx+b>0$，对$y=-1$的实例点，有$wx+b\le 0$，则称数据集线性可分，否则线性不可分。

2.一些问题

2.1$\vec{w}$是超平面的法向量？

如图在$w^T+b=0$上任意取两个点$x_1,x_2$

即得：$$\{\begin{array}{l}{w}^T{x}_1+b=0\\ w^T{x}_2+b=0\end{array}\to w^T(x_1-x_2)=0$$
即得：$$\vec{w}\cdot \overrightarrow{(x_1-x_2)}=0\to \vec{w}\perp \overrightarrow{(x_1-x_2)}$$
所以得到如下图所示：
所以可以推导出$\vec{w}$是超平面的法向量。

2.2从点到超平面的距离$\to$Loss Function

预备知识：点到平面的距离怎么求？
设点为$P$，在平面上任取一点$A$，距离就等于$\overrightarrow{PA}$往单位法向量上的投影，如图所示：
$|PQ|=\overrightarrow{PA}在\vec{n}(法向量)的投影=\frac{|\overrightarrow{PA}\cdot \vec{n}|}{|\vec{n}|}$，分子是绝对值，分母是模。

回到问题：求d？
在$w^{T}x+b=0$上，任取一点$x^{{}^{\prime }}$，则$d=\frac{|w^T\cdot (x-x^{{}^{\prime }})|}{||w|{|}_2}$，这里$w$的$L2$范式就是模长。
即
$$\{\begin{array}{l}{w}^T{x}^{{}^{\prime }}+b=0\to b=-w^T{x}^{{}^{\prime }}\\ d=\frac{|w^T\cdot (x-x^{{}^{\prime }})|}{||w|{|}_2}=\frac{|w^{T}x-w^T{x}^{{}^{\prime }}|}{||w|{|}_2}=\frac{|w^{T}x+b|}{||w|{|}_2}\end{array}$$
至此，距离的表达式就推导出来了。

3.loss function推导

很自然的会想到用误分类点的数目来作为损失函数，是误分类点个数越来越少，最终全部分对就可以了，建立如下所示的loss function（这样的损失函数并不是w，b连续可导（无法用可导函数形式来表达出误分类点的个数），无法进行优化。）：
$$l(w,b)=\sum _{i=1}^{N}I(y_i(w^T{x}_i+b)<0)$$
对于指示函数的由来：考虑正确分类$(w^T{x}_i+b)>0,y_i=+1$，$y{w}^T{x}_i+b)<0,y_i=-1$，得到正确的$y_i(w^T{x}_i+b)>0$，反之小于0就是错误分类
这个式子的推导过程：
首先思考如果分类错误：
当$f(x_i)=sign(w^T{x}_i+b)=+1$，而$y_i=-1$，所以$w^T{x}_i+b>0$，即$y_i(w^T{x}_i+b)<0$；
当$f(x_i)=sign(w^T{x}_i+b)=-1$，而$y_i=+1$，所以$w^T{x}_i+b<0$，即$y_i(w^T{x}_i+b)<0$。
所以可以将这两类情况统一起来，即分错就是$y_i(w^T{x}_i+b)<0$，最后得到$l(w,b)={\sum }_{i=1}^{N}I(y_i(w^T{x}_i+b)<0)$，$I$为指示函数，不可导（原因就是w变化，I就会从0变到1或者1变到0），所以需要将它换一种形式，转变为点到超平面的距离，即：$$L(w,b)=\sum _{x_i\in M}\frac{|w^{T}x+b|}{||w|{|}_2}$$，$M$是所有误分类点的集合，后面是距离和。
进一步，因为$|w^{T}x+b|$还是有点不可导，所以由误分类的点都有$y_i(w^T{x}_i+b)<0$，且$y_i=-1,+1$，不影响数值，所以就可以将绝对值去掉，再往前面加个负号，让距离变成正数，即实现了最终的loss function：$$L(w,b)=\sum _{x_i\in M}\frac{-y_i(w^T{x}_i+b)}{||w|{|}_2}$$

4.学习策略（最优化）

梯度下降（用的SGD）
$minL(w,b)=min{\sum }_{x_i\in M}\frac{-y_i(w^T{x}_i+b)}{||w|{|}_2}\propto min-{\sum }_{x_i\in M}{y}_i(w^T{x}_i+b)$
这里最终的loss变成了$$L(w,b)=\sum _{x_i\in M}-y_i(w^T{x}_i+b)$$
$\{\begin{array}{l}{\nabla }_{w}L(w,b)=-\sum y_i{x}_i\\ {\nabla }_{b}L(w,b)=-\sum y_i\end{array}$
对每个误分类$(x_i,y_i)$对$w,b$更新，$w\leftarrow w+{\sum }_{x_i\in M}{y}_i{x}_i\cdot \eta$，$b\leftarrow b+{\sum }_{x_i\in M}{y}_i\cdot \eta$

为什么用SGD？
1.因为偏导为0，不一定是全局极值点，但全局极值点的偏导一定为0。
2.计算过于复杂（有可能要求逆矩阵）。
3.偏导=0没有解析解。

5.遗留问题，最终loss function为什么舍去$\frac{1}{||w|{|}_2}$?

感知机的任务是进行二分类工作，它最终并不关心得到的超平面离各点的距离有多少（所以我们最后才可以不考虑$w$的范式），只是关心最后是否已经分类正确（也就是考虑误分类点的个数），比如说下面两条线，对于感知机来说，效果任务是一样的。

6.感知机的实现代码

代码一：

train_set = [[(3, 3), 1], [(4, 3), 1], [(1, 1), -1]]
# 初始化w参数
w = [0, 0]
# 初始化b参数
b = 0
# 学习率
n = 1

# 数据格式测试
# item = train_set[0]
# s1 = item[1]*item[0][0]
# s2 = 1* item[1]*item[0][0]
# print(s1, s2)

# 更新参数
def update(item):
    global w,b
    # w更新
    for i in range(len(w)):
        w[i] += n * item[1] * item[0][i]
    # b更新
    b += n * item[1]
    print('w = ', w, 'b = ', b)


# 判断yi*(w*xi+b)，来说明是否误判
def judge(item):
    
    res = 0
    # 其实用numpy更好
    # w*x
    for i in range(len(w)):
        res += item[0][i] * w[i]
    # w*x+b
    res += b
    # y*(w*x+b)
    res *= item[1]
    return res

def check():
    flag = False
    for item in train_set:
        # 判断是否误分
        if judge(item) <= 0:
            # True就是误分类
            flag = True
            update(item)
    return flag

if __name__ == '__main__':
    flag = False
    count = 1000
    for i in range(count):
        if not check():  # 假如分类正确，跳出当前，进行下一次
            flag = True
            break
    if flag:
        print("分对了")
    else:
        print('没分对')

结果：

w =  [3, 3] b =  1
w =  [2, 2] b =  0
w =  [1, 1] b =  -1
w =  [0, 0] b =  -2
w =  [3, 3] b =  -1
w =  [2, 2] b =  -2
w =  [1, 1] b =  -3

代码二：
jupyter文件链接

# 1.必要的包
import pandas as pd  # 读取数据集
from sklearn.datasets import load_iris  # 用到鸢尾花数据集，注意它是3个种类，所以后面要处理一下
import numpy as np
import matplotlib.pyplot as plt  # 画图用

# 2.加载数据
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df.head(5)   # 查看前5行数据
df['label'] = iris.target
df.head(5)
# 去掉特征名的单位
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']

# 3.画出原始数据离散图
# 这里用前50个，是因为我们已知数据是这样分布的，0-100才是线性可分的，不能用100-150
plt.scatter(df[:50]['sepal length'], df[:50]['sepal width'], label='0')
plt.scatter(df[50:100]['sepal length'], df[50:100]['sepal width'], label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('orignal data')
plt.legend()
plt.show()

# 在这里我们只保留sepal两个属性，petal舍去，只做简单的线性模型
data = np.array(df.iloc[:100, [0, 1, -1]])  # 另外加上标签项 -1
X, y = data[:, :-1], data[:, -1]  # 再从data中分离出属性和标签

X, y

y = [1 if i== 1 else -1 for i in y]  # 变成感知机所需要的-1和1两种
# y = np.array(y, dtype=X[0][0].dtype)
# 测试一下
np.zeros(len(X[0]), dtype=X[0][0].dtype)

# 4.建立感知机模型
class Model:
    def __init__(self) -> None:
        # 初始化w和b
        self.w = np.zeros(len(X[0]), dtype=X[0][0].dtype)  # w
        self.b = 0  # b
        self.l_rate = 0.1  # 学习率


    # 判断yi*(w*xi+b)，来说明是否误判
    def judge(self, x, w, b, y):
        # y*(w*x+b)
        res = np.dot(x, w) + b
        res *= y
        # print('1: ', res)
        return res

    # 更新参数
    def update(self, x, y):
        # w更新
        self.w = self.w + self.l_rate * np.dot(y, x)
        # b更新
        self.b = self.b + self.l_rate * y

    def fit(self, X_train, y_train):
        wrong_flag = False
        while not wrong_flag:
            wrong_count = 0
            for i in range(len(X_train)):
                X, y = X_train[i], y_train[i]

                if self.judge(X, self.w, self.b, y) <= 0:
                    # 说明误分类了，需要更新参数w,b
                    self.update(X, y)
                    wrong_count += 1
            if wrong_count == 0:
                wrong_flag = True
        return 'Perceptron Model'

perceptron = Model()
perceptron.fit(X, y)

perceptron.w, perceptron.b

# 5.训练结果
# 先画线
x_points = np.linspace(4, 7, 10)
y_ = -(perceptron.w[0] * x_points + perceptron.b) / perceptron.w[1]
plt.plot(x_points, y_)
plt.plot(data[:50, 0], data[:50, 1], 'bo', color='blue', label='0')
plt.plot(data[50:100, 0], data[50:100, 1], 'bo', color='orange', label='1')
plt.xlabel('sepal length')
plt.ylabel('sepal width')
plt.title('result')
plt.legend()
plt.show()

7.收敛证明

我们需要证明经过有限次迭代可以得到一个将训练数据集完全正确划分的分离超平面及感知机模型。
首先将$b$并入权重向量$w$，记为：$\hat{w}=(w^T,b{)}^T,\hat{x}=(x^T,1{)}^T,\hat{x}\in {\mathbb{R}}^{n+1},\hat{w}\in {\mathbb{R}}^{n+1},\hat{w}\cdot \hat{x}=w\cdot x+b$，设训练集$T=\{(x_1,y_1),(x_2,y_2),...,(x_n,y_n),\}$是线性可分的，则下面两个定理成立（感知机收敛定理）：
(1)存在满足条件$||{\hat{w}}_{opt}||=1$的超平面${\hat{w}}_{opt}=w_{opt}\cdot x+b_{opt}=0$；且存在$\gamma$，对所有$i=1,2,...,N$，$y_i({\hat{w}}_{opt}\cdot {\hat{x}}_i)=y_i(w_{opt}\cdot x_i+b_{opt})\ge \gamma$；
(2)令$R=ma{x}_{1\le i\le N}||{\hat{x}}_i||$，感知机算法在训练集的误分类次数$k$满足不等式，$k\le {\left(\frac{R}{\gamma }\right)}^2$。

定理一的证明：

由线性可分，存在超平面${\hat{w}}_{opt}=w_{opt}\cdot x+b_{opt}=0$使得$||{\hat{w}}_{opt}||=1$（当$||{\hat{w}}_{opt}||$为任意值时，都可以使得$w_{opt}\cdot x+b_{opt}=0$，$w_{opt}与b_{opt}$同时放缩不改变超平面，如$2x+2=0和x+1=0$是同一条直线），由有限个点，均有$y_i({\hat{w}}_{opt}\cdot {\hat{x}}_i)=y_i(w_{opt}\cdot x_i+b_{opt})>0$，此时超平面已经确定，将所有的点分对了，所以所有的训练集数据点均满足$y_i(w_{opt}\cdot x_i+b_{opt})>0$，那么必然$\exists r=\min y_i(w_{opt}\cdot x_i+b_{opt})，且r>0$，则$y_i({\hat{w}}_{opt}\cdot {\hat{x}}_i)=y_i(w_{opt}\cdot x_i+b_{opt})\ge \gamma$。

定理二的证明：

令${\hat{w}}_{k-1}$是第$k$个误分类的点（实例）之前的扩充权值向量（就是将b加进去了），即$${\hat{w}}_{k-1}={\left(w_{k-1}^T,b_{k-1}\right)}^T$$，

现在第$k$个实例，被误分了，所以它满足：$$y_i\left({\hat{w}}_{k-1}\cdot {\hat{x}}_i\right)=y_i\left(w_{k-1}{x}_i+b_{i-1}\right)\le 0$$，也就是代码里误分的判断条件，所以需要更新参数：$$\{\begin{array}{l}{w}_k\leftarrow w_{k-1}+\eta \cdot y_i{x}_i\\ b_k\leftarrow b_{k-1}+\eta \cdot y_i\end{array}$$，则得到一个重要的式子${\hat{w}}_k={\hat{w}}_{k-1}+\eta \cdot y_i{\hat{x}}_i$，这里一定要注意维度。

接下来需要证明两个结论：$$\{\begin{array}{l}(1){\hat{w}}_k\cdot {\hat{w}}_{opt}\ge k\eta \gamma \\ (2)||{\hat{w}}_{k-1}|{|}^2\le k{\eta }^2{R}^2\end{array}$$

先证明$(1)$：$$\begin{array}{rl}{\hat{w}}_k\cdot {\hat{w}}_{opt}& =({\hat{w}}_{k-1}+\eta \cdot y_i{\hat{x}}_i){\hat{w}}_{opt},这一步用了上面的式子{\hat{w}}_k={\hat{w}}_{k-1}+\eta \cdot y_i{\hat{x}}_i\\ & \ge {\hat{w}}_{k-1}\cdot {\hat{w}}_{opt}+\eta \cdot r,这一步用到了定理1:y_i({\hat{w}}_{opt}\cdot {\hat{x}}_i)\ge \gamma \end{array}$$

至此，得到$$\begin{array}{rl}{\hat{w}}_k\cdot {\hat{w}}_{opt}& \ge {\hat{w}}_{k-1}\cdot {\hat{w}}_{opt}+\eta \cdot r\\ & \ge {\hat{w}}_{k-2}\cdot {\hat{w}}_{opt}+2\eta \cdot r,这一步{\hat{w}}_{k-1}\cdot {\hat{w}}_{opt}\ge {\hat{w}}_{k-2}\cdot {\hat{w}}_{opt}+\eta \cdot r\\ & \ge \cdots \\ & \ge k\eta \gamma \end{array}$$

证毕。

再证明(2)：

条件：$R={\max }_{1\le i\le N}||{\hat{x}}_i||$

$$\begin{array}{rl}||{\hat{w}}_k|{|}^2& =||{\hat{w}}_{k-1}+\eta y_i{\hat{x}}_i|{|}^2\\ & =||{\hat{w}}_{k-1}|{|}^2+2\eta y_i{\hat{w}}_{k-1}{\hat{x}}_i+{\eta }^2||y_i{\hat{x}}_i|{|}^2,这一步：2\eta y_i{\hat{w}}_{k-1}{\hat{x}}_i=C,所以不需要模长\\ & \le ||{\hat{w}}_{k-1}|{|}^2+{\eta }^2||y_i{\hat{x}}_i|{|}^2,这一步是因为我们之前令第k个点误分类所以y_i{\hat{w}}_{k-1}{\hat{x}}_i<0\\ & \le ||{\hat{w}}_{k-1}|{|}^2+{\eta }^2{R}^2,这一步是因为条件R=\underset{1\le i\le N}{\max }||{\hat{x}}_i||\\ & \le ||{\hat{w}}_{k-2}|{|}^2+2{\eta }^2{R}^2\\ & \le \cdots \\ & \le k{\eta }^2{R}^2\end{array}$$

最后由两个结论：$$\{\begin{array}{l}(1){\hat{w}}_k\cdot {\hat{w}}_{opt}\ge k\eta \gamma \\ (2)||{\hat{w}}_{k-1}|{|}^2\le k{\eta }^2{R}^2\end{array}$$得：$$k\eta \gamma \le {\hat{w}}_k{\hat{w}}_{opt}\le ||{\hat{w}}_k||\cdot ||{\hat{w}}_{opt}||\le \sqrt{k}\eta R$$，第二个$\le$由$\vec{a}\cdot \vec{b}=|\vec{a}|\cdot |\vec{b}|\cos \theta \le |\vec{a}|\cdot |\vec{b}|$，第三个$\le$是定理1条件$||{\hat{w}}_{opt}||=1$，即$$k\eta \gamma \le \sqrt{k}\eta R\to k{\gamma }^2\le R^2\to k\le {\left(\frac{R}{\gamma }\right)}^2$$,

至此，即证 $k$有上界，为有限集。

8.对偶

根据查阅资料，普遍的观点是以下俩点：

1.从对偶形式学习算法过程可以看出，样本点的特征向量以内积的形式存在于感知机对偶形式的训练算法中，凡是涉及到矩阵，向量内积的运算量就非常大（现实中特征维度很高），这里我们如果事先计算好所有的内积，存储于Gram矩阵中，以后碰到更新的点，直接从Gram矩阵中查找即可，相当于我就初始化运算一遍Gram矩阵，以后都是查询，大大加快了计算速度。

2.跟SVM的对偶形式其实有类似之处。