【李航】统计学习方法--2. 感知机（详细推导）

最新推荐文章于 2023-03-07 11:46:10 发布

顾道长生'

最新推荐文章于 2023-03-07 11:46:10 发布

阅读量1.1k

点赞数 2

分类专栏：机器学习文章标签：人工智能机器学习感知机分类算法

本文链接：https://blog.csdn.net/wl1780852311/article/details/119055578

版权

机器学习专栏收录该内容

75 篇文章 46 订阅

订阅专栏

本文详细介绍了感知机模型，包括其原理、点到线和样本到超平面的距离计算、超平面概念，以及感知机的学习策略。感知机学习算法分为原始形式和对偶形式，其中原始形式通过不断调整权重向量w和偏置b，使得误分类点逐渐被正确分类，而对偶形式则主要更新系数α和b，利用 Gram 矩阵简化计算。此外，还给出了两种形式的 Python 代码实现。

摘要由CSDN通过智能技术生成

在这里插入图片描述

目录

感知机原理
点到线的距离
样本到超平面距离
超平面（Hyperplanes）

感知机模型
感知机的学习策略
损失函数

感知机学习算法
原始形式
对偶形式
问题

思考
代码实现
原始形式
对偶形式

感知机原理

感知机是二分类的线性模型，其输入是实例的特征向量，输出的是实例的类别，分别是+1和-1，属于判别模型。
假设训练数据集是线性可分的，感知机学习的目标是求得一个能够将训练数据集 正实例点和负实例点完全正确分开的分离超平面 。如果是非线性可分的数据，则最后无法获得超平面
点到线的距离
- 公式中的直线方程为 $A x + B y + C = 0$ , 点 $P$ 的坐标为 $\left(x_{0}, y_{0}\right)$ 。
  $d=\frac{A x_{0}+B y_{0}+C}{\sqrt{A{2}+B{2}}}$
样本到超平面距离
- 我们假设超平面是 $\cdot x+b$ , 其中 $w=\left(w_{0}, w_{1}, \ldots w_{m}\right), x=\left(x_{0}, x_{1}, \ldots x_{m}\right)$ , 样本点 $x^{\prime}$ 到超平面的距离如下:
  $d=\frac{w \cdot x^{\prime}+b}{\|w\|}$
超平面（Hyperplanes）
- 超平面是在空间 $R^d$ 中的一个子空间 $R^{d-1}$ 。在2维空间中的超平面是一条线，在3维空间中的超平面是-一个平面。

感知机模型

定义 感知机假设输入空间(特征空间)是 $\subseteq R^{n}$ , 输出空间是 $\mathrm{y}=\{+1,-1\}_{\circ}$ 输入 $\in X$ 表示实例的特征向量, 对应于输入空间(特征空间)的点; 输出 $\in Y$ 表示实例的类别。有输入空间到输出空间的如下函数 $f(x)=\operatorname{sign}(w \bullet x+b)\quad$ 称为感知机。其中 $w$ 和 $b$ 为感知机模型参数, $\in R^{n}$ 叫做权值(weight)或权值向量(weight vector), $\in R$ 叫作偏置(bias), $\bullet x$ 表示 $\mathrm{w}$ 和 $\mathrm{x}$ 的内积。 $\operatorname{sign}$ 是符号函数，即:
$\operatorname{sign}(x)= \begin{cases}+1, & x \geqslant 0 \\ -1, & x<0\end{cases}$
感知机是一种线性分类模型，属于判别模型
感知机的几何解释是线性方程：
$\bullet x+b=0$
对应于特征空间 $R^{n}$ 中的一个超平面 $S$ ，其中 $w$ 是从超平面的法向量， $b$ 是超平面的截距。
这个超平面将特征空间划分为两个部分。位于两部分的点(特征向量)分别被分为 正、负两类 。
因此，超平面S成为分离超平面(separating hyperplane),如图2.1所示。

感知机学习，由训练数据集(实例的特征向量及类别)
$T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \ldots,\left(x_{N}, y_{N}\right)\right\}\}$
其中 $x_{i} \in X=R^{n}, y_{i} \in Y=\{+1,-1\}, i=1,2, \ldots, N$ , 求得感知机模型 $f (x)$ , 即求得模型参数 $b_{\circ}$ 感知机预测，通过学习得到的感知机模型，对于新的输入实例给出其对应的输出类别。
- 证明为什么w是直线（高维空间下为超平面）的法向量

感知机的学习策略

损失函数

损失函数的一个自然选择是误分类点的总数, 但是这样损失函数不是参数 $w$ 和 $b$ 的连续可到函数, 不易优化。损失函数的另一个选择是误分类点到超平面 $S$ 的总距离, 这是感知机所采用的。为此，首先写出输入空间 $R^{n}$ 中任一点 $x_{0}$ 到超平面S的距离 $\frac{1}{\|w\|}\left|w \bullet x_{0}+b\right|$ ,这里, $\|w\|$ 是w的 $L_{2}$ 范数。其次, 对于误分类的数据 $\left(x_{i}, y_{i}\right)$ 来说, $-y_{i}\left(w \bullet x_{i}+b\right)>0$ 成立。因为当 $\bullet x_{i}+b>0$ 时, $y_{i}=-1$ , 而当 $\bullet x_{i}+b<0$ 时, $y_{i}=+ 1$ 。因此, 误分类点 $x_{i}$ 到超平面S的距离是 $\frac{1}{\|w\|} y_{i}\left(w \bullet x_{i}+b\right)$ 这样, 假设超平面 $S$ 的误分类点集合为 $M,$ 那么所有误分类点到超平面S的总距离为 $\frac{1}{\|w\|} \sum_{x_{i}\in M} y_{i}\left(w \bullet x_{i}+b\right)$ 不考虑 $\frac{1}{\|w\|}$ , 就得到感知机学习的损失函数。
为什么不考虑 $\frac{1}{\|w\|}$ ？？
有人说 $\frac{1}{\|w\|}$ 是个定值, 但是我觉得平面不唯一, 这个值肯定也会变。通过参考他人观点结合思考, 觉得原因可以列为以下两点。
1. $\frac{1}{\|w\|}$ 不影响 $y_{i}\left(w \cdot x_{i}+b\right)$ 正负的判断, 即不影响学习算法的中间过程。因为感知机学习算法是误分类驱动的, 这里需要注意的是所谓的 “误分类驱动" 指的是我们只需要判断 $y_{i}\left(w \cdot x_{i}+b\right)$ 的正负来判断分类的正确与否, 而 $\frac{1}{\|w\|}$ 并不影响正负值的判断。所以 $\frac{1}{\|w\|}$ 对感知机学习算法的中间过程可以不考虑。
2. $\frac{1}{\|w\|}$ 不影响感知机学习算法的最终结果。因为感知机学习算法最终的终止条件是所有的输入都被正确分类，即不存在误分类的点。则此时损失函数为 0 . 对应于 $-\frac{1}{\|w\|} \sum_{i \in M} y_{i}\left(w \cdot x_{i}+b\right)$ , 即分子为 0 . 则可以看出 $\frac{1}{\|w\|}$ 对最终结果也无影响。
综上所述, 即使忽略 $\frac{1}{\|w\|}$ , 也不会对感知机学习算法的执行过程产生任何影响。反而还能简化运算, 提高算法执行效率。

感知机学习算法

原始形式

算法 2.1 (感知机学习算法的原始形式)
输入：训练数据集 $T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \ldots,\left(x_{N}, y_{N}\right)\right\} , 其中 x_{i} \in X=R^{n}, y_{i} \in Y=-1,+1, i=1,2, \ldots, N$ ; 学习率 $\eta(0<\eta \leq 1)$ ;
输出： $w$ , $b$ ; 感知机模型 $f(x)=\operatorname{sign}(w \bullet x+b)$
1. 选取初值 $w_{0}$ , $b_{0}$
2. 在训练集中选取数据 $\left(x_{i}, y_{i}\right)$
3. 如果 $y_{i}\left(w \cdot x_{i}+b\right) \leqslant 0$ ,
  $\begin{aligned} &w \leftarrow w+\eta y_{i} x_{i} \\ &b \leftarrow b+\eta y_{i} \end{aligned}$
4. 转至 $2$ ,直至训练集中没有误分类点。
直观解释当一个实例点被误分类，及位于分离超平面的错误一侧时，则调整w, b的值，使分离超平面向该误分类点的一侧移动，以减少该误分类点与超平面的距离，直至超平面越过该误分类点使其被正确分类。

过渡到对偶形式

对偶形式的基本想法是, 将 $w$ 和 $b$ 表示为实例 $x_{i}$ 和标记 $y_{i}$ 的线性组合的形式, 通过求解其系数而求得 $w$ 和 $b$ 。不失一般性, 假设初始值 $w_{0}, b_{0}$ 均为 0 。对误分类点 $\left(x_{i}, y_{i}\right)$ 通过
$\begin{aligned} &w \leftarrow w+\eta y_{i} x_{i} \\ &b \leftarrow b+\eta y_{i} \end{aligned}$
逐步修改 $w, b$ , 设修改 $n$ 次, 则 $w, b$ 关于 $\left(x_{i}, y_{i}\right)$ 的增量分别是 $\alpha_{i} y_{i} x_{i}$ 和 $\alpha_{i} y_{i}$ , 这里 $\alpha_{i}=n_{i} \eta$ . 这样, 从学习过程不难看出, 最后学习到的 $w, b$ 可以分别表示为
$\begin{gathered} w=\sum_{i=1}^{N} \alpha_{i} y_{i} x_{i} \\ b=\sum_{i=1}^{N} \alpha_{i} y_{i} \end{gathered}$

对偶形式

算法 2.2 (感知机学习算法的对偶形式)
输入：线性可分的数据集 $T=\left\{\left(x_{1}, y_{1}\right),\left(x_{2}, y_{2}\right), \ldots,\left(x_{N}, y_{N}\right)\right\}$ , 其中 $x_{i} \in R, y_{i} \in\{-1,+1\}, i=1,2, \ldots, N$ ; 学习率 $\eta(0<\eta \leq 1) \text { ; }$
输出: $\alpha, b ;$ 感知机模型 $f(x)=\operatorname{sign}\left(\sum_{j=1}^{N} \alpha_{j} y_{j} x_{j} \bullet x+b\right)$
其中 $\alpha=\left(\alpha_{1}, \alpha_{2}, \ldots, \alpha_{N}\right)^{T}$
1. $\alpha \leftarrow 0, b \leftarrow 0$
2. 在训练集中选取数据 $\left(x_{i}, y_{i}\right)$
3. 如果 $y_{i}\left(\sum_{j=1}^{N} \alpha_{j} y_{j} x_{j} \bullet x_{i}+b\right) \leq 0$
  $\begin{aligned} &\alpha_{i} \leftarrow \alpha_{i}+\eta \\ &b \leftarrow b+\eta y_{i} \end{aligned}$
4. 转至 $2$ 直到没有误分类数据。
对偶形式中训练实例仅以内积的形式出现，为了方便，可以预先将训练集中实例间的内积计算出来并以矩阵形式存储，这个矩阵就是所谓的Gram矩阵(Gram matrix)
$G=\left[x_{i} \bullet x_{j}\right]_{M \times N}$
问题
1. Gram矩阵是如何计算的？
2. 对偶形式求得的浮点数如何处理？
  $w$ 不用必须是整数，浮点数也可以
3. 怎么理解 $\eta_{i}$ ？？
  $\eta_{i}$ 表示的是第 $i$ 个样本点被误判的次数，而感知机一般形式中的 $w$ 其实就是每个样本点被误判的次数乘以 $x_{i}y_{i}$ 的累加和，也就是 $\sum _ { i = 1 } ^ { N } \eta_{i}{\eta}x_{i}y_{i}$ 。在每次迭代的时候， $\eta_{i}$ 表示的是到当前为止，第 $i$ 个样本点被误判的次数，这个很重要。因为要反复让样本点中的输入 $x$ 两两相乘(这个在一般形式中计算 $w$ 的时候也要这样，自己模拟一遍就发现了)，所以提前搞成一个矩阵存起来，类似于平时刷算法题说的打表。所以两个形式本质上是一样的，不过把 $w$ 用另外一种形式表示。

思考

$N$ 为训练集大小， $n$ 为特征数量

对偶形式：扫一遍 $N$ ，计算每条数据在之前被加了几个（ $a_{i}$ ）次（当 $\eta$ 取 $1$ 时， $a_{i}$ 相当于第i组数据的梯度 $x_{i}y_{i}$ 被加了几次，找到一个误分点后直接加上，而不是每次加），因为 $x_{i}x_{j}$ 已经被提前计算在Gram矩阵中，所以每次是 $O （ 1 ）$ ，那么扫一遍 $N$ 就是 $O （ N ）$ 。
原始形式：每次计算 $w * x$ ，计算此内积复杂度为 $O （ n ）$

所以看下来，选择哪种计算方法取决于训练集和特征数量的大小。

代码实现

原始形式

对于输入空间，感知机通过以下函数将其映射至 ${+1,-1\}\}$ 的输出空间
$f(x)=\operatorname{sign}(w \cdot x+b)$
1. 对于所有的错分类点 $\in M$ , 都有 $-y_{i}\left(w \cdot x_{i}+b\right)>0$ , 因此我们可以定义如下的损失函数作为优化准则:
  $b)=-\sum_{x_{i} \in M} y_{i}\left(w \cdot x_{i}+b\right)$
2. 通过求解损失函数的梯度,
  $\begin{array}{l}\nabla_{w} L(w, b)=-\sum_{x_{i} \in M} y_{i} x_{i} \\\nabla_{b} L(w, b)=-\sum_{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. 选取初值 $w_{0}, b_{0}$
  2. 在训练集中任意选取点 $x_{i},y_{i})$
  3. 如果 $y_{i}\left(w \cdot x_{i}+b\right)>0$ 则按照 $3$ 式更新 $\mathrm{w}, \mathrm{b}$
  4. 重复 $2$ 直到没有被误分的点

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


def train(epoch,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.dot(train_array[:,0:-1] , train_array[:,0:-1].T)
    for idx in range(epoch):
        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(epoch=500,train_datas=train_datas,lr=0.01)
    plot_points(train_datas,w,b)

在这里插入图片描述

对偶形式

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

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


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.dot(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)