Bishop 模式识别与机器学习读书笔记 || 线性分类模型之判别函数的几何建模

线性分类模型之判别函数的几何建模

分类问题是将输入向量 $\mathbf{x}\in R^d$ 分配到 $K$ 个离散的类 $\{{\mathcal{C}}_k|k=1,\cdots ,k\}$ 中，通常，一个输入只能分配且只能分配到唯一的一个类。输入空间被分界面分割成不同的决策域，如果分类面是输入向量 $\mathbf{x}$ 的线性函数时，此分类面可以看作是 $D$ 维空间中的 $D-1$ 维分类面，即数据集被超平面严格分开，称为 线性可分。

分类问题可以分为两分类和多分类问题，对于输入向量 $\mathbf{x}$，二分类的输出为 $t\in \{0,1\}$，对于多分类问题，出输出采用 One-hot 的方式，如 5 类问题的第二类 $\mathbf{t}=(0,1,0,0,0)$.

构造分类函数的方法主要有三种：

（1）直接构造判别函数 $y(\mathbf{x})=f({\mathbf{w}}^T\mathbf{x}+w_0)$.

（2）通过概率构造 $p({\mathcal{C}}_k|\mathbf{x})$，通过概率的大小确定类别。

（3）通过概率构造生成模型，通过先验和似然获取后验概率，即
$$p({\mathcal{C}}_k|\mathbf{x})=\frac{p(\mathbf{x}|{\mathcal{C}}_k)p({\mathcal{C}}_k)}{p(\mathbf{x})}$$

1. 判别函数

在线性回归模型中，通过 $y(\mathbf{x})={\mathbf{w}}^T\mathbf{x}+w_0$ 来获取一个实数值，如果需要判断一个类别时，我们可以通过构造一种函数，将函数值限制在 $[0,1]$ 中，为了达到这种效果，我们可以借助于一个非线性函数 $f(\cdot )$ 来构造参数 $\mathbf{w}$ 的线性函数
$$y(\mathbf{x})=f({\mathbf{w}}^T\mathbf{x}+w_0)$$
在机器学习中， $f(\cdot )$ 称为激活函数，在统计学中该函数的拟函数称为连接函数。相应地，决策面函数为
$$y(\mathbf{x})=\text{constant}$$
也可以写作
$${\mathbf{w}}^T\mathbf{x}+w_0=\text{constant}\text{\hspace{1em}(1)}$$
因此，尽管 $f(\cdot )$ 是非线性函数，但是分界面公式（1）仍然是关于 $\mathbf{x}$ 一个线性函数，称为广义线性模型。

1.1 两类问题

线性判别函数最简单的表示是通过取输入向量 $\mathbf{x}$ 的线性函数来获得的
$$y(\mathbf{x})={\mathbf{w}}^T\mathbf{x}+w_0$$
其中 $w$ 被称为权重向量，$w_0$ 是偏置（不要与统计学意义上的偏差混淆）。如果输入向量 $\mathbf{x}$ 对应的函数值 $y(\mathbf{x})\ge 0$，则被分配到第一类 $\mathbf{x}\in {\mathcal{C}}_1$，否则， $\mathbf{x}\in {\mathcal{C}}_2$. 因此，对应的判定边界由函数 $y(\mathbf{x})=0$ 确定，该关系对应于 $D$ 维输入空间内的 $(D-1)$ 维超平面。考虑位于决策面上的两个点 ${\mathbf{x}}_A$ 和 ${\mathbf{x}}_B$，由于 $y({\mathbf{x}}_A)=y({\mathbf{x}}_B)=0$，因此有 ${\mathbf{w}}^T({\mathbf{x}}_A-{\mathbf{x}}_B)=0$，因此向量 $\mathbf{w}$ 与位于决策曲面内的每个向量正交， $\mathbf{w}$ 确定决策曲面的方向(即向量 $\mathbf{w}$ 是决策面的法向量)。类似地，如果 $\mathbf{x}$ 是决策曲面上的一个点，那么 $y(\mathbf{x})=0$ ，即
$$\frac{{\mathbf{w}}^T\mathbf{x}}{||\mathbf{w}||}=\frac{-w_0}{||\mathbf{w}||}$$
**注释：**上式表明分界面上的向量在绿色直线上的投影，即原点到分界面的距离。

对于空间中任意一点 $\mathbf{x}$，可以表示为
$$\mathbf{x}={\mathbf{x}}_{\perp }+r\cdot \frac{\mathbf{w}}{\Vert \mathbf{w}\Vert }\text{\hspace{1em}(2)}$$
公式（2）两边左乘 ${\mathbf{w}}^T$，然后加上 $w_0$，得
$${\mathbf{w}}^T\mathbf{x}+w_0={\mathbf{w}}^T{\mathbf{x}}_{\perp }+w_0+r\cdot \frac{{\mathbf{w}}^T\mathbf{w}}{\Vert \mathbf{w}\Vert }$$
即，点到直线的距离 $r$ 为
$$r=\frac{y(\mathbf{x})}{\Vert \mathbf{w}\Vert }$$

注释： 公式(2)中的系数 $r$ 可看作是向量的模。

为了书写更加简洁，可引入哑变量 $x_0=1$，然后定义 $\mathbf{w}=(w_0,\mathbf{w})$ 和 $\mathbf{x}=(x_0,\mathbf{x})$，则
$$y(\mathbf{x})={\mathbf{w}}^T\mathbf{x}$$

1.2 多类问题

$$y_k(\mathbf{x})={\mathbf{w}}_k^T\mathbf{x}+w_{k0}$$

$$({\mathbf{w}}_k-{\mathbf{w}}_j{)}^T\mathbf{x}+(w_{k0}-w_{j0})=0$$

$$\hat{\mathbf{x}}=\lambda {\mathbf{x}}_A+(1-\lambda ){\mathbf{x}}_B$$

$$y_k(\hat{\mathbf{x}})=\lambda y_k({\mathbf{x}}_A)+(1-\lambda )y_k({\mathbf{x}}_B)$$

多分类问题的最小二乘法：
$$y_k(\mathbf{x})={\mathbf{w}}_k^T\mathbf{x}+w_{k0}$$

$$\mathbf{y}(\mathbf{x})=\left(\begin{array}{c}{y}_1(\mathbf{x})\\ y_2(\mathbf{x})\\ ⋮\\ y_K(\mathbf{x})\end{array}\right)=\left(\begin{array}{c}{\mathbf{w}}_1^T\\ {\mathbf{w}}_2^T\\ ⋮\\ {\mathbf{w}}_K^T\end{array}\right)\mathbf{x}={\mathbf{W}}^T\mathbf{x}$$

$$E_D(\mathbf{W})=\frac{1}{2}Tr\{(\mathbf{X}\mathbf{W}-\mathbf{T}{)}^T(\mathbf{X}\mathbf{W}-\mathbf{T})\}$$

$$\frac{\partial E_D(\mathbf{W})}{\partial \mathbf{W}}={\mathbf{X}}^T(\mathbf{X}\mathbf{W}-\mathbf{T})={\mathbf{X}}^T\mathbf{X}\mathbf{W}-{\mathbf{X}}^T\mathbf{T}=0$$

$$\mathbf{W}=\underset{{\mathbf{X}}^{†}}{({\mathbf{X}}^T\mathbf{X}{)}^{-1}{\mathbf{X}}^T}\mathbf{T}={\mathbf{X}}^{†}\mathbf{T}$$

$$\mathbf{y}(\mathbf{x})={\mathbf{W}}^T\mathbf{x}={\mathbf{T}}^T({\mathbf{X}}^{†}{)}^T\mathbf{x}$$

1.3 Fisher 线性判别 LDA 算法

分类面在空间中的表示方法：

过原点的直线(法向量为 $\mathbf{w}$)
$${\mathbf{w}}^T\mathbf{x}=0$$
不过原点的直线(法向量为 $\mathbf{w}$)
$${\mathbf{w}}^T\mathbf{x}=c$$
有一种分类建模的方法是从降维的角度认识的，将 $D$ 维空间上的输入向量 $\mathbf{x}$ 投影到一维直线上，可通过内积形式完成
$$y={\mathbf{w}}^T\mathbf{x}$$
可对y设置一个阈值进行分类，当 $y\ge -w_0$ 则认为是类 ${\mathcal{C}}_1$，否则为类${\mathcal{C}}_2$. 一般来说，投影到一维上会导致大量的信息丢失，并且在原始的D维空间中很好地分离的类可能在一维中变得很强地重叠。然而，通过调整权重向量 $\mathbf{w}$ 的分量，我们可以选择最大化类分离的投影。

对于一个两类问题，其中有 ${\mathcal{C}}_1$ 类的 $N_1$ 个点和 ${\mathcal{C}}_2$ 类的 $N_2$ 个点，因此这两类的平均向量表示为
$${\mathbf{m}}_1=\frac{1}{N_1}\sum _{n\in {\mathcal{C}}_1}{\mathbf{x}}_n,{\mathbf{m}}_2=\frac{1}{N_1}\sum _{n\in {\mathcal{C}}_2}{\mathbf{x}}_n$$
两个中心点到直线上的投影分别为
$$m_1={\mathbf{w}}^T{\mathbf{m}}_1,m_2={\mathbf{w}}^T{\mathbf{m}}_2$$
为使得两类尽可能的分开，最直接的方式是满足两个中心点的投影距离最大，即
$$\begin{gathered} \underset{\mathbf{w}}{\max }(m_2-m_1{)}^2=\{{\mathbf{w}}^T({\mathbf{m}}_2-{\mathbf{m}}_1)\left\}\right\{{\mathbf{w}}^T({\mathbf{m}}_2-{\mathbf{m}}_1){\}}^T \\ ={\mathbf{w}}^T\{({\mathbf{m}}_2-{\mathbf{m}}_1)({\mathbf{m}}_2-{\mathbf{m}}_1{)}^T\}\mathbf{w} \\ ={\mathbf{w}}^T{\mathbf{S}}_B\mathbf{w} \end{gathered}$$
为了防止两类投影点有重叠现象，我们希望每一类的投影方差是最小的，即
$$\begin{gathered} s_1^2=\sum _{n\in {\mathcal{C}}_1}(y_n-m_1{)}^2 \\ =\sum _{n\in {\mathcal{C}}_1}({\mathbf{w}}^T{\mathbf{x}}_n-{\mathbf{w}}^T{\mathbf{m}}_1{)}^2 \\ =\sum _{n\in {\mathcal{C}}_1}\{{\mathbf{w}}^T({\mathbf{x}}_n-{\mathbf{m}}_1){\}}^2 \\ ={\mathbf{w}}^T\{\sum _{n\in {\mathcal{C}}_1}({\mathbf{x}}_n-{\mathbf{m}}_1)({\mathbf{x}}_n-{\mathbf{m}}_1{)}^T\}\mathbf{w} \end{gathered}$$
相似地，
$$\begin{gathered} s_2^2=\sum _{n\in {\mathcal{C}}_2}(y_n-m_2{)}^2 \\ =\sum _{n\in {\mathcal{C}}_2}({\mathbf{w}}^T{\mathbf{x}}_n-{\mathbf{w}}^T{\mathbf{m}}_2{)}^2 \\ =\sum _{n\in {\mathcal{C}}_2}\{{\mathbf{w}}^T({\mathbf{x}}_n-{\mathbf{m}}_2){\}}^2 \\ ={\mathbf{w}}^T\{\sum _{n\in {\mathcal{C}}_2}({\mathbf{x}}_n-{\mathbf{m}}_2)({\mathbf{x}}_n-{\mathbf{m}}_2{)}^T\}\mathbf{w} \end{gathered}$$
综合以上两式，需要类内方差和最小，即
$$\begin{gathered} \underset{\mathbf{w}}{\min }{s}_1^2+s_2^2={\mathbf{w}}^T\{\sum _{n\in {\mathcal{C}}_1}({\mathbf{x}}_n-{\mathbf{m}}_1)({\mathbf{x}}_n-{\mathbf{m}}_1{)}^T\}\mathbf{w}+{\mathbf{w}}^T\{\sum _{n\in {\mathcal{C}}_2}({\mathbf{x}}_n-{\mathbf{m}}_2)({\mathbf{x}}_n-{\mathbf{m}}_2{)}^T\}\mathbf{w} \\ ={\mathbf{w}}^T\{\sum _{n\in {\mathcal{C}}_1}({\mathbf{x}}_n-{\mathbf{m}}_1)({\mathbf{x}}_n-{\mathbf{m}}_1{)}^T+\sum _{n\in {\mathcal{C}}_2}({\mathbf{x}}_n-{\mathbf{m}}_2)({\mathbf{x}}_n-{\mathbf{m}}_2{)}^T\}\mathbf{w} \\ ={\mathbf{w}}^T{\mathbf{S}}_W\mathbf{w}\text{\hspace{1em}(6)} \end{gathered}$$
综合（3）和（6），分类的目标函数为
$$\underset{\mathbf{w}}{\max }J=\frac{{\mathbf{w}}^T{\mathbf{S}}_B\mathbf{w}}{{\mathbf{w}}^T{\mathbf{S}}_W\mathbf{w}}\text{\hspace{1em}(7)}$$
为求公式（7）的极值点，可通过对其进行求导获得
$$\frac{\partial J}{\partial \mathbf{w}}=\frac{({\mathbf{w}}^T{\mathbf{S}}_B\mathbf{w}){\mathbf{S}}_W\mathbf{w}-({\mathbf{w}}^T{\mathbf{S}}_W\mathbf{w}){\mathbf{S}}_B\mathbf{w}}{{\mathbf{w}}^T{\mathbf{S}}_W\mathbf{w}{\mathbf{w}}^T{\mathbf{S}}_W\mathbf{w}}=0$$
即
$$({\mathbf{w}}^T{\mathbf{S}}_B\mathbf{w}){\mathbf{S}}_W\mathbf{w}=({\mathbf{w}}^T{\mathbf{S}}_W\mathbf{w}){\mathbf{S}}_B\mathbf{w}\text{\hspace{1em}(8)}$$
由于 ${\mathbf{S}}_B\mathbf{w}=({\mathbf{m}}_2-{\mathbf{m}}_1)({\mathbf{m}}_2-{\mathbf{m}}_1{)}^T\mathbf{w}=\text{constant}\cdot ({\mathbf{m}}_2-{\mathbf{m}}_1)$，

又因为我们只关心w的方向，而不关心它的长度，可认为 ${\mathbf{w}}^T{\mathbf{S}}_B\mathbf{w}={\text{constant}}_1$，${\mathbf{w}}^T{\mathbf{S}}_w\mathbf{w}={\text{constant}}_2$，因此，公式（8）可改写为
$${\mathbf{S}}_W\mathbf{w}=\text{constant}\cdot ({\mathbf{m}}_2-{\mathbf{m}}_1)\text{\hspace{1em}(9)}$$
公式（9）两边同时左乘 ${\mathbf{S}}_W^{-1}$，得
$$\mathbf{w}\propto {\mathbf{S}}_W^{-1}\cdot ({\mathbf{m}}_2-{\mathbf{m}}_1)\text{\hspace{1em}(10)}$$
公式（10）就是著名的 Fisher 判别法 （Linear Discriminant Analysis, LDA），此时，只给出了求投影直线的方法，并没有进行分类。确定分类面，我们还需要确定一个阈值 $y_0$，判断 ${\mathbf{w}}^T\mathbf{x}$ 与阈值的大小关系

• 如 ${\mathbf{w}}^T\mathbf{x}\ge y_0$，则 $\mathbf{x}\in {\mathcal{C}}_1$

• 如 ${\mathbf{w}}^T\mathbf{x}<y_0$，则 $\mathbf{x}\in {\mathcal{C}}_2$

1.3 代码实现

# 利用 linear Descriminant Analysis (LDA, 又称 Fisher判别分析) 方法进行二分类,
# 结果中的直线不是分类线，是投影直线；阈值是需要事先设定的，此处是利用的投影均值。

import numpy as np
import matplotlib.pyplot as plt

# 生成两类数据集
def createDataSet():
    # 类别1
    X1 = np.mat(np.random.random((50, 2)) * 5 + 15)
    # 类别2
    X2 = np.mat(np.random.random((40, 2)) * 5 + 2)
    return X1, X2

#
def average(dataset):
    ave = []
    a, b = np.shape(dataset)
    for i in range(b):
        n = np.sum(dataset[:, i]) / a
        ave.append(n)
    return np.array(ave)

def compute_sw(dataset, ave):
    sw = 0
    a, b = np.shape(dataset)
    for i in range(a - 1):
        sw += np.dot(dataset[i, :] - ave, (dataset[i, :] - ave).T)
    return np.array(sw)


x1_x, x2_x = createDataSet()
x1_x_ave = average(x1_x)
x2_x_ave = average(x2_x)

x1_sw = compute_sw(x1_x, x1_x_ave)
x2_sw = compute_sw(x2_x, x2_x_ave)
Sw = x1_sw + x2_sw

# 求广义逆
pinv = np.linalg.pinv(Sw)
w = np.multiply(x1_x_ave - x2_x_ave, pinv)[0, :]
print('w 的值为：', w)


data = np.vstack((x1_x,x2_x))
y = np.dot(w,data.T)

thresh = np.mean(y)
a=np.array(y>thresh)
ind1 = a[0,:]
a=np.array(y<thresh)
ind2 = a[0,:]
print('两类数据的类标号', ind1)

x1_x = np.array(x1_x)
x2_x = np.array(x2_x)
data = np.vstack((x1_x,x2_x))

test = np.array([15,10])
test =test.reshape((-1,1))
cls = np.dot(w,test)>thresh
print('测试为第一类的结果为：',cls)

# 画图
plt.figure()
plt.scatter(data[:,0],data[:,1])
x = np.arange(-5,10,0.01)
y = -w[0]*x/w[1]
plt.plot(x,y)
plt.scatter(data[ind1,0],data[ind1,1])
plt.scatter(data[ind2,0],data[ind2,1])


plt.show()

1.4 结果输出

w 的值为： [0.03483013 0.03467873]
两类数据的类标号 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True  True  True
  True  True False False False False False False False False False False
 False False False False False False False False False False False False
 False False False False False False False False False False False False
 False False False False False False]
测试为第一类的结果为： [ True]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5HjlEHab-1669101371512)(Img/Fisher.png)]

注释：

LDA算法既可以用来降维，又可以用来分类，但是目前来说，主要还是用于降维。在我们进行图像识别图像识别相关的数据分析时，LDA是一个有力的工具。下面总结下LDA算法的优缺点。

• LDA算法的主要优点有：

  1）在降维过程中可以使用类别的先验知识经验，而像PCA这样的无监督学习则无法使用类别先验知识。

  2）LDA在样本分类信息依赖均值而不是方差的时候，比PCA之类的算法较优。

• LDA算法的主要缺点有：

  1）LDA不适合对非高斯分布样本进行降维，PCA也有这个问题。

  2）LDA降维最多降到类别数k-1的维数，如果我们降维的维度大于k-1，则不能使用LDA。当然目前有一些LDA的进化版算法可以绕过这个问题。

  3）LDA在样本分类信息依赖方差而不是均值的时候，降维效果不好。

  4）LDA可能过度拟合数据。

2. 感知机方法

2.1 回顾分类面在空间中的表示方法：

过原点的直线(法向量为 $\mathbf{w}$)
$${\mathbf{w}}^T\mathbf{x}=0$$
不过原点的直线(法向量为 $\mathbf{w}$)
$${\mathbf{w}}^T\mathbf{x}=c或{\mathbf{w}}^T\mathbf{x}-c=0$$
则 ${\mathbf{x}}^{\prime }$ 带入上式得
$${\mathbf{w}}^T{\mathbf{x}}^{\prime }-c>0$$
则 ${\mathbf{x}}^{\prime \prime }$ 带入上式得
$${\mathbf{w}}^T{\mathbf{x}}^{\prime \prime }-c<0$$
由上可知，令 ${\mathbf{x}}^{\prime }$ 对应的类为正类，即 $t^{\prime }=+1$， ${\mathbf{x}}^{\prime \prime }$ 对应的类为负类，即 $t^{\prime \prime }=-1$ 则有

正确分类的情形：
$$t^{\prime }({\mathbf{w}}^T{\mathbf{x}}^{\prime }-c)>0，t^{\prime \prime }({\mathbf{w}}^T{\mathbf{x}}^{\prime \prime }-c)>0$$
错误分类的情形：
$$t^{\prime \prime }({\mathbf{w}}^T{\mathbf{x}}^{\prime }-c)<0，t^{\prime }({\mathbf{w}}^T{\mathbf{x}}^{\prime \prime }-c)<0$$
综上可知，对于任意的数据 $({\mathbf{x}}_i,t_i)$，错分的总和为
$$\sum _{i=1}^N{t}_i({\mathbf{w}}^T{\mathbf{x}}_i-c)<0$$
由于上式中的误差和为负数，可构造相反数变成正数，同时令 $-c=b$，则对于错误分类的集合$M$，损失函数(感知机学习的经验风险函数或错误率)为

$$E(\text{w},b)=-\sum _{{\text{x}}_i\in M}{y}_i({\text{w}}^T{\text{x}}_i+b)\text{\hspace{1em}(11)}$$
注释： 公式（11）只考虑错误分类的数据，对于正确分类的视而不见，即正确分类数据不影响参数 $\text{w}$。

公式（11）的极小化问题为
$$(\hat{\mathbf{w}},\hat{b})=\arg \underset{\text{w},b}{\min }E(\mathbf{w},b)$$
关于$\text{w}$求偏导数
$$\frac{\partial E(\text{w},b)}{\partial \text{w}}=-\sum _{x_i\in M}{y}_i{\text{x}}_i$$
关于 $b$ 求偏导
$$\frac{\partial E(\text{w},b)}{\partial b}=-\sum _{x_i\in M}{t}_i$$

对于错分数据集（根据 $t_i({\mathbf{w}}^T{\mathbf{x}}_i-c)<0$ 判断），由于采用随机梯度下降，一次随机选取一个误分类点 $({\mathbf{x}}_i,t_i)$ 的参数更新公式为：
$$\begin{gathered} \text{w}\leftarrow \text{w}+\eta t_i{\text{x}}_i \\ b\leftarrow b+\eta \sum _{x_i\in M}{t}_i \end{gathered}$$
2.2 感知机算法：

初始化 ${\text{w}}_0$ 和 $b_0$

步1：如果误分类，即 $t_i({\text{w}}^T{\text{x}}_i+b)<0$

步2：执行 $\text{w}$ 和 $b$ 的更新\

步3：返回步1，直至没有误分点

# !/usr/bin/env python
# -*- coding:utf-8 -*-

"""
author:LEE CZ

The form of perceptron
"""

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D

# 可视化展示分类结果
def plotResult(dataMat, labelMat, weight, bias,fig):
    
    axes = fig.add_subplot(111)
    # 设置坐标轴的显示范围
    plt.xlim(-5, 10)
    plt.ylim(-5, 10)
    
    axes.scatter(dataMat[:,0],dataMat[:,1],c=labelMat[:])
    

    y = (0.1 * -weight[0] / weight[1] + -bias / weight[1], 4.0 * -weight[0] / weight[1] + -bias / weight[1])
    axes.add_line(Line2D((0.1, 4.0), y, linewidth=1, color='blue'))

    plt.xlabel('X')
    plt.ylabel('Y')

    plt.pause(1)
    plt.cla()
    


# 感知机算法
def trainPerceptron(dataMat, labelMat, eta,fig):
    m, n = dataMat.shape
    weight = np.zeros(n)
    bias = 0

    flag = True
    while flag:
        for i in range(m):
            if np.any(labelMat[i] * (np.dot(weight, dataMat[i]) + bias) <= 0):
                weight = weight + eta * labelMat[i] * dataMat[i].T
                bias = bias + eta * labelMat[i]
                print('weight is {}, bias is {}'.format(weight, bias))

                plotResult(dataMat, labelMat, weight, bias,fig)
                flag = True
                break
            else:
                flag = False

    return weight, bias


if __name__ == "__main__":
    # 导入数据，并确定X和y
    data = np.loadtxt('testSet.txt')
    dataMat = data[:, 0:2]
    labelMat = data[:, 2]
    eta = 1 # 步长，或学习率
    
    fig = plt.figure()
    
    weight, bias = trainPerceptron(dataMat, labelMat, 1,fig)
    plotResult(dataMat, labelMat, weight, bias,fig)
    print(labelMat)
    print('The final weight is {}, the final bias is {}'.format(weight, bias))

weight is [3. 3.], bias is -1.0
weight is [2. 2.], bias is -2.0
weight is [1. 1.], bias is -3.0
weight is [ 0. -1.], bias is -4.0
weight is [3. 2.], bias is -3.0
weight is [2. 1.], bias is -4.0
weight is [0.  0.5], bias is -5.0
weight is [3.  3.5], bias is -4.0
weight is [2.  2.5], bias is -5.0
weight is [0. 2.], bias is -6.0
weight is [3. 5.], bias is -5.0
weight is [2. 4.], bias is -6.0
weight is [1. 3.], bias is -7.0
weight is [0. 1.], bias is -8.0
weight is [3. 4.], bias is -7.0
weight is [2. 3.], bias is -8.0
weight is [1. 1.], bias is -9.0
weight is [4. 4.], bias is -8.0
weight is [3. 3.], bias is -9.0
weight is [2. 1.], bias is -10.0
weight is [5. 4.], bias is -9.0
weight is [4. 3.], bias is -10.0
weight is [3. 1.], bias is -11.0
weight is [6. 3.], bias is -10.0
weight is [4.  2.5], bias is -11.0
[-1. -1.  1.  1. -1.  1.  1. -1.]
The final weight is [4.  2.5], the final bias is -11.0

2.3 感知机模型的对偶

误分点的更新过程
$$\begin{gathered} \mathbf{w}:=\mathbf{w}+\eta t_i{\mathbf{x}}_i \\ b:=b+\eta t_i \end{gathered}$$
若 $({\mathbf{x}}_i,t_i)$ 在 $n_i$ 次循环中均被看做误分点，（不失一般性，设 ${\mathbf{w}}_0=0,b_0=0$），则 $\mathbf{w},b$ 关于点$({\mathbf{x}}_i,t_i)$ 的增量分别为 $(n_i\eta )t_i{\mathbf{x}}_i$ 和 $(n_i\eta )t_i$

即 $\mathbf{w},b$ 关于 $({\mathbf{x}}_i,y_i)$ 点的增量可记为(令 ${\alpha }_i=n_i\eta$ )
$$\begin{gathered} \Delta {\mathbf{w}}_{(x_i,y_i)}={\alpha }_i{t}_i{\mathbf{x}}_i \\ \Delta b_{(x_i,y_i)}={\alpha }_i{t}_i \\ \Delta {\alpha }_i=\eta \end{gathered}$$

从全数据的执行，最终学到的 $\mathbf{w}$ 和 $b$ 分别为
$$\begin{gathered} \mathbf{w}=\sum _{i=1}^N{\alpha }_i{t}_i{\mathbf{x}}_i \\ b=\sum _{i=1}^N{\alpha }_i{t}_i \end{gathered}$$
则判断准则 $t_i({\mathbf{w}}^T{\mathbf{x}}_i+b)<0$ 可重写为
$$t_i(\sum _{j=1}^N{\alpha }_j{t}_j{\mathbf{x}}_j^T{\mathbf{x}}_i+b)<0$$
即
$$t_i(\sum _{j=1}^N{\alpha }_j{t}_j\underset{向量的内积}{({\mathbf{x}}_j,{\mathbf{x}}_i)}+b)<0$$
更新过程：
$$\begin{gathered} {\alpha }_i:={\alpha }_i+\eta \\ b:=b+\eta t_i \end{gathered}$$
直至所有点均无误分的情况

注：对偶方法的优势在于只计算内积 $({\mathbf{x}}_i,{\mathbf{x}}_j)$，内积矩阵为Gram矩阵，因此在引入核函数时非常有利，无需知道 $y=\varphi (\mathbf{x})$ 的形式。

"""
author:LeeCZ

The dual form of perceptron
"""

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D


# 载入数据集
def loadData():
    data = np.loadtxt('testSet.txt')
    dataMat = data[:, 0:2]
    labelMat = data[:, 2]
    labelMat = labelMat.reshape((labelMat.shape[0], 1))
    return dataMat, labelMat


"""
训练模型
b:bias
eta:learning rate
"""
def trainModel(dataMat, labelMat, alpha, b, eta):
    flag = True
    while flag:
        for i in range(m):
            if (labelMat[i, 0] * (np.sum((alpha * labelMat * np.dot(dataMat, dataMat[i].T).reshape((m, 1)))) + b)) <= 0:
                alpha[i] = alpha[i] + eta
                b = b + eta * labelMat[i]
                flag = True
                break
            else:
                flag = False
    w = np.dot(dataMat.T, alpha * labelMat)
    return w, b


# 可视化结果
def plotResult(dataMat, labelMat, weight, bias):
    fig = plt.figure()
    axes = fig.add_subplot(111)

    axes.scatter(dataMat[:,0],dataMat[:,1],c=labelMat[:,0])

    y = (0.1 * -weight[0] / weight[1] + -bias / weight[1], 4.0 * -weight[0] / weight[1] + -bias / weight[1])
    axes.add_line(Line2D((0.1, 4.0), y, linewidth=1, color='blue'))

    plt.xlabel('X')
    plt.ylabel('Y')

    plt.show()

   

# 主函数
if __name__ == "__main__":
    dataMat, labelMat = loadData()
    m, n = dataMat.shape
    alpha = np.zeros((m, 1))
    b = 0
    eta = 1
    w, b = trainModel(dataMat, labelMat, alpha, b, eta)
    print('weight is {}, \n bias is {}'.format(w, b))
 
    plotResult(dataMat, labelMat, w, b)

结果

weight is [[4. ]
 [2.5]], 
 bias is [-11.]

3. 小结