机器学习之支持向量机SVM（二）

第二次总结支持向量机，主要涉及到实现SVM的算法—SMO算法，分为简易版和完整版。打卡，7月1号之前完成~

一、SMO算法的最优化问题分析

SMO算法要解决的凸二次规划的对偶问题：$$\begin{gathered} \underset{\alpha }{\min }\frac{1}{2}\sum _{i=1}^N\sum _{j=1}^N{\alpha }_i{\alpha }_j{y}_i{y}_{j}K(x_i,x_j)-\sum _{i=1}^N{\alpha }_i \\ s.t.\sum _{i=1}^N{\alpha }_i{y}_i=0 \\ 0⩽{\alpha }_i⩽C，i=1,2,\dots ,N \end{gathered}$$
注：在写数学公式的时候，光标出现了问题，之前光标是一条线，想在哪里修改就在哪里修改。不知道哪里出现了问题，光标变成了一个蓝框，公式编起来非常麻烦。

解决方法：

切换光标的模式的方法为按 insert 键。笔记本电脑有的需要同时按 Fn + insert 键能在三种状态之间切换。

SMO算法是一种启发式算法，其主要思想为：选择两个变量${\alpha }_1,{\alpha }_2$，固定其他变量，针对这两个变量建立一个二次规划问题，形式为：
$$\begin{gathered} \underset{{\alpha }_1,{\alpha }_2}{\min }W({\alpha }_1,{\alpha }_2)=\frac{1}{2}{K}_{11}{\alpha }_1^2+\frac{1}{2}{K}_{22}{\alpha }_2^2+y_1{y}_2{K}_{12}{\alpha }_1{\alpha }_2-({\alpha }_1+{\alpha }_2) \\ +y_1{\alpha }_1\sum _{i=3}^N{y}_i{\alpha }_i{K}_{i1}+y_2{\alpha }_2\sum _{i=3}^N{y}_i{\alpha }_i{K}_{i,2} \\ s.t.{\alpha }_1{y}_1+{\alpha }_2{y}_2=-\sum _{i=3}^N{y}_i{\alpha }_i=\varsigma \\ 0⩽{\alpha }_i⩽C，i=1,2 \end{gathered}$$

1.无约束下的二次规划问题的极值

令$${\nu }_i=\sum _{j=3}^N=g(x_i)-\sum _{j=1}^2{\alpha }_j{y}_{j}K(x_i,x_j)-b,i=1,2$$
目标函数为：
$$\begin{gathered} W({\alpha }_1,{\alpha }_2)==\frac{1}{2}{K}_{11}{\alpha }_1^2+\frac{1}{2}{K}_{22}{\alpha }_2^2+y_1{y}_2{K}_{12}{\alpha }_1{\alpha }_2-({\alpha }_1+{\alpha }_2) \\ +y_1{\nu }_1{\alpha }_1+y_2{\nu }_2{\alpha }_2 \end{gathered}$$
由${\alpha }_1{y}_1=\varsigma -{\alpha }_2{y}_2$及$y_1^2=1$,可将${\alpha }_1$表示为：
$${\alpha }_1=(\varsigma -y_2{\alpha }_2)y_1$$
带入到$W({\alpha }_1,{\alpha }_2)$的表达式中，
$$\begin{gathered} W({\alpha }_2)=\frac{1}{2}{K}_{11}(\varsigma -y_2{\alpha }_2{)}^2+\frac{1}{2}{K}_{22}{\alpha }_2^2+y_2{K}_{12}(\varsigma -y_2{\alpha }_2){\alpha }_2 \\ -(\varsigma -y_2{\alpha }_2)y_1-{\alpha }_2+{\nu }_1(\varsigma -y_2{\alpha }_2)+y_2{\nu }_2{\alpha }_2 \end{gathered}$$
对${\alpha }_2求偏导，$
$$\begin{gathered} \frac{\partial W}{\partial {\alpha }_2}=K_{11}{\alpha }_2+K_{22}{\alpha }_2-2K_{12}{\alpha }_2-K_{11}\varsigma y_2-K_{12}\varsigma \\ {y}_2+y_1{y}_2-1-{\nu }_1{y}_2+y_2{\nu }_2 \end{gathered}$$
令其为0，得到，
$$\begin{gathered} (K_{11}+K_{22}-2K_{12}){\alpha }_2=y_2(y_2-y_1+\varsigma K_{11}-\varsigma K_{12}+{\nu }_1-{\nu }_2) \\ =y_2[y_2-y_1+\varsigma K_{11}-\varsigma K_{12}+(g(x_1)-\sum _{j=1}^2{\alpha }_j{y}_{j}K(x_i,x_j)-b) \\ -(g(x_2)-\sum _{j=1}^2{\alpha }_j{y}_{j}K(x_i,x_j)-b)] \end{gathered}$$
将$\varsigma ={\alpha }_1^{old}{y}_1+{\alpha }_2^{old}{y}_2$代入,
$$\begin{gathered} (K_{11}+K_{22}-2K_{12}){\alpha }_2^{new,nuc}=y_2((K_{11}+K_{22}-2K_{12}){\alpha }_2^{old}{y}_2+y_2-y_1 \\ +g(x_1)-g(x_2)) \\ =(K_{11}+K_{22}-2K_{12}){\alpha }_2^{old}+y_2(E_1-E_2) \end{gathered}$$
将$\eta =K_{11}+K_{22}-2K_{12}$代入，
$${\alpha }_2^{new,nuc}={\alpha }_2^{old}+\frac{y_2(E_1-E_2)}{\eta }$$

2.约束条件下的可行域问题

由于只有两个变量，我们可以用如图所示的正方形区域来表示.
假设该优化问题的的初始可行解为 ${\alpha }_1^{old},{\alpha }_2^{old}$ ，最优解为 ${\alpha }_1^{new},{\alpha }_2^{new}$一旦一个变量确定，另一个变量也可以确定下来，因为：
$${\alpha }_1^{new}{y}_1+{\alpha }_2^{new}{y}_2={\alpha }_1^{old}{y}_1+{\alpha }_2^{old}{y}_2$$

接下来，我们讨论${\alpha }_2$的可行域：
由${\alpha }_1{y}_1+{\alpha }_2{y}_2=-\sum _{i=3}^N{y}_i{\alpha }_i=\varsigma$,
1.如果$y_1̸=y_2$,则原式可以变为：${\alpha }_1-{\alpha }_2=k$
如左图所示，
1）当k<0时，直线位于右下方位置，
直线不管怎么移动，对应的${\alpha }_2$的最大值为C，最小值为直线下端点与${\alpha }_2$轴的交点，这个点${\alpha }_1=0$，故有，$$0-{\alpha }_2^{new}={\alpha }_1^{old}-{\alpha }_2^{old}$$$${\alpha }_2^{new}={\alpha }_2^{old}-{\alpha }_1^{old}$$
此时，${\alpha }_2\in [{\alpha }_2^{old}-{\alpha }_1^{old},C]$
2)当k>0时，直线位于左上角位置，
直线不管怎么移动，对应的${\alpha }_2$的最小值为0，最大值为直线上端点与${\alpha }_2$轴的平行轴的交点，这个点${\alpha }_1=C$，故有$$C-{\alpha }_2^{new}={\alpha }_1^{old}-{\alpha }_2^{old}$$$${\alpha }_2^{new}=C+{\alpha }_2^{old}-{\alpha }_1^{old}$$
此时，${\alpha }_2\in [0,C+{\alpha }_2^{old}-{\alpha }_1^{old}]$
又因为，$0⩽{\alpha }_i⩽C$
设L,H分别为${\alpha }_2$的上界和下界，$$L=max(0,{\alpha }_2^{old}-{\alpha }_1^{old})$$$$H=min(C+{\alpha }_2^{old}-{\alpha }_1^{old},C)$$
2.如果$y_1=y_2$,则原式可以变为：${\alpha }_1+{\alpha }_2=k$
如右图所示，
1）当0 直线不管怎么移动，对应的${\alpha }_2$的最小值为0，最大值为直线上端点与${\alpha }_2$轴的平行轴的交点，这个点${\alpha }_1=0$，故有$$0+{\alpha }_2^{new}={\alpha }_1^{old}+{\alpha }_2^{old}$$$${\alpha }_2^{new}={\alpha }_2^{old}+{\alpha }_1^{old}$$
此时，${\alpha }_2\in [0,{\alpha }_2^{old}+{\alpha }_1^{old}]$
2)当C 直线不管怎么移动，对应的${\alpha }_2$的最大值为C，最小值为直线上端点与${\alpha }_2$轴的平行轴的交点，这个点${\alpha }_1=C$，故有$$C+{\alpha }_2^{new}={\alpha }_1^{old}+{\alpha }_2^{old}$$$${\alpha }_2^{new}={\alpha }_2^{old}+{\alpha }_1^{old}-C$$
此时，${\alpha }_2\in [{\alpha }_2^{old}+{\alpha }_1^{old}-C,C]$
又因为，$0⩽{\alpha }_i⩽C$
设L,H分别为${\alpha }_2$的上界和下界，$$L=max(0,{\alpha }_2^{old}+{\alpha }_1^{old}-C)$$$$H=min({\alpha }_2^{old}+{\alpha }_1^{old},C)$$
由以上分析，我们得出最终的解${\alpha }_2^{new,unc}$满足：
$${\alpha }_2^{new,unc}=\{\begin{array}{ll}H& {\alpha }_2^{new,unc}>H\\ {\alpha }_2^{new,unc}& L\le {\alpha }_2^{new,unc}\le H\\ L& {\alpha }_2^{new,unc}<L\end{array}$$

二、两个变量的选择问题

1.第一个变量的选择问题

SMO算法把寻找第一个变量的过程称为外循环。外循环是在训练样本集中选取违反KKT条件最严重的的点作为第一个变量。如何判断样本点是否满足KKT条件？
原始问题是凸二次规划问题，求得的KKT条件，
$$\begin{gathered} {\nabla }_{w}L(w^{\ast },b^{\ast },{\xi }^{\ast },{\alpha }^{\ast },{\mu }^{\ast })=w^{\ast }-\sum _{i=1}^N{\alpha }^{\ast }{y}_i{x}_i=0 \\ {\nabla }_{b}L(w^{\ast },b^{\ast },{\xi }^{\ast },{\alpha }^{\ast },{\mu }^{\ast })=-\sum _{i=1}^N{\alpha }_i{y}_i=0 \\ \nabla L(w^{\ast },b^{\ast },{\xi }^{\ast },{\alpha }^{\ast },{\mu }^{\ast })=C-{\alpha }^{\ast }-{\mu }^{\ast }=0 \\ {\alpha }^{\ast }(y_i(w^{\ast }{x}_i+b^{\ast })-1+{\xi }^{\ast })=0 \\ {\mu }^{\ast }{\xi }^{\ast }=0 \\ {y}_i(w^{\ast }{x}_i+b^{\ast })-1+{\xi }_i^{\ast }\ge 0 \\ {\xi }_i^{\ast }\ge 0 \\ {\alpha }_i^{\ast }\ge 0 \\ {\mu }_i^{\ast }\ge 0 \end{gathered}$$
进一步的，
1.当${\alpha }_i=0$时，则 ${\mu }^{\ast }=C\Rightarrow {\xi }^{\ast }=0\Rightarrow y_i(w^{\ast }{x}_i+b^{\ast })-1\ge 0$；
2.当${\alpha }_i=C$时，则${\mu }^{\ast }=0\Rightarrow y_i(w^{\ast }{x}_i+b^{\ast })-1+{\xi }_i^{\ast }=0\Rightarrow y_i(w^{\ast }{x}_i+b^{\ast })=1-{\xi }_i^{\ast }\le 1$；
3.当$0<{\alpha }_i<C$时，则${\xi }^{\ast }=0，y_i(w^{\ast }{x}_i+b^{\ast })-1+{\xi }_i^{\ast }=0\Rightarrow y_i(w^{\ast }{x}_i+b^{\ast })=1$
完整的，
$$\begin{gathered} {\alpha }_i=0⟺y_i(w^{\ast }{x}_i+b^{\ast })\ge 1 \\ {\alpha }_i=C⟺y_i(w^{\ast }{x}_i+b^{\ast })\le 1 \\ 0<{\alpha }_i<C⟺y_i(w^{\ast }{x}_i+b^{\ast })=1 \end{gathered}$$
选择第一个变量的流程如下：

1. 遍历整个训练样本的数据集，找到违反KKT条件的${\alpha }_i$作为第一个变量，然后根据后面讲到的规则选择第二个变量，接着对这两个变量进行优化。
2. 当遍历完整个训练样本的数据集后，接着遍历间隔边界上的样本点，根据相关规则选择第二个变量，接着对这两个变量进行优化。
3. 返回1，继续遍历整个训练样本点数据集。即在整个样本的数据集和非边界样本上来回进行切换。直到遍历整个样本的数据集，没有可以优化的${\alpha }_i$为止，退出循环。

对于第一个变量的选择，在《机器学习实战》中有具体的代码实现：

这里有一个问题：为什么这样写呢？
前面我们已经解释了满足KKT条件的表达式，如果不满足KKT条件，则可以表达为：
$$\begin{gathered} {\alpha }_i=0⟺y_i(w^{\ast }{x}_i+b^{\ast })<1 \\ {\alpha }_i=C⟺y_i(w^{\ast }{x}_i+b^{\ast })>1 \\ 0<{\alpha }_i<C⟺y_i(w^{\ast }{x}_i+b^{\ast })>1或y_i(w^{\ast }{x}_i+b^{\ast })<1 \end{gathered}$$
进一步的，可以转化成：
$$当y_i(w^{\ast }{x}_i+b^{\ast })>1时，0<{\alpha }_i\le C$$$$当y_i(w^{\ast }{x}_i+b^{\ast })<1时，0\le {\alpha }_i<C$$
我们看代码中的表达式，$E_i=g(x_i)-y_i$
对于$\forall \delta >0$
1.当${\alpha }_i<C$，即$0\le {\alpha }_i<C$
$$\begin{array}{rl}{y}_i[g(x_i)-y_i]& =y_{i}g(x_i)-y_i{y}_i\\ & =y_{i}g(x_i)-1<-\delta \\ & =y_{i}g(x_i)<1-\delta \end{array}$$
2.当${\alpha }_i>0$，即$0<{\alpha }_i\le C$
$$\begin{array}{rl}{y}_i[g(x_i)-y_i]& =y_{i}g(x_i)-y_i{y}_i\\ & =y_{i}g(x_i)-1>\delta \\ & =y_{i}g(x_i)>1+\delta \end{array}$$
这里，$\delta$是一个误差项。

2.第二个变量的选择问题

SMO称第二个变量的选择过程为内循环。第二个变量的选择的标准是使${\alpha }_i$有足够大的变化.由于${\alpha }_2$是依赖于$|E_1-E_2|$的，则我们选择使得$|E_1-E_2|$最大的${\alpha }_2$。如果$E_1$是正的，则选择最小的$E_i$作为$E_2$；如果$E_1$是负的，则选择最大的$E_i$作为$E_2$；通常为每个样本的 $E_i$保存在一个列表中，选择最大的 $|E_1-E_2|$来近似最大化步长。

按照上述的启发式选择第二个变量，如果不能够使得函数值有足够的下降，则需要：

遍历在间隔边界上的支持向量点，找到能够使目标函数下降的点，如果没有，则遍历整个数据集；如果还是没有合适的${\alpha }_2$，则放弃第一个${\alpha }_1$,通过外层循环重新选择${\alpha }_1$。

三.简易版的SMO算法

from numpy import *
import matplotlib.pyplot as plt
# SMO算法中的辅助函数
# 读取文本中的数据，将文本中的特征存放在dataMat中，将标签存放在labelMat中
def loadDataSet(fireName):
    DataMat = [];LabelMat = []
    fr = open(fireName)
    for line in fr.readlines():
        LineArr = line.strip().split('\t')
        DataMat.append([float(LineArr[0]),float(LineArr[1])])
        LabelMat.append(float(LineArr[2]))
    return DataMat,LabelMat
# 随机选择alpha_j的索引值
def SelectJrand(i,m):
    j = i
    while(j == i):
        j = int(random.uniform(0,m))
    return j
#判断alpha值是否越界
def clipAlpha(aj,H,L):
    if aj > H:
        aj = H
    elif aj < L:
        aj = L
    return aj

SMO算法正式部分

# 该函数的伪代码如下：
#    创建一个alpha向量并将其初始化为0向量
#    当迭代次数小于最大的迭代次数时（外循环）：
#        对数据集中的每个数据向量（内循环）：
#            如果该数据向量可以被优化：
#                 随机选择另外一个数据向量
#                 同时优化这两个向量
#                 如果这两个向量都不能被优化，退出内循环
#    如果所有的向量都没有被优化，增加迭代数目，继续下一次循环
def smoSimple(dataMatIn,classLabels,C,toler,MaxIter):
    # 将列表 dataMatIn 和 classLabels转化成矩阵，运用矩阵乘法来减少运算
    dataMatrix = mat(dataMatIn)
    LabelMat = mat(classLabels).transpose()# .transpose()是转置运算
    # 初始化y = w*x + b 	的 b 为0
    b = 0
    # 得到 dataMatrix 的行数和列数
    m,n = shape(dataMatrix)
    # 初始化 alphas 为 m×1的零矩阵
    alphas = mat(zeros((m,1)))
    iter = 0
    # 开始迭代
    while (iter < MaxIter):
        # 记录alphas是否已经发生了优化
        alphaPairsChanged = 0
        # 遍历数据集上的每一个样本
        for  i  in range(m):
            # 计算第一个变量alphas[i]的预测值
            gxi = float(multiply(alphas,LabelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b
            # 计算第一个变量的预测值与真实值的差
            Ei = gxi - float(LabelMat[i])
            # 选择违反 KKT 条件的样本点进行优化，为什么这么处理，我们在正文中有说明
            if (LabelMat[i]*Ei < -toler and alphas[i] < C) or (LabelMat[i]*Ei > toler and alphas[i] > 0):
                # 选择好了i，就开始选择另外一个变量i
                j = SelectJrand(i,m)
                # 计算第二个变量的预测值
                gxj = float(multiply(alphas,LabelMat).T*(dataMatrix*dataMatrix[j,:].T)) + b
                # 计算第二个变量的预测值和真实值的差
                Ej =gxj - float(LabelMat[j])
                # 储存alpha的初始值
                alphaIold = alphas[i].copy()
                alphaJold = alphas[j].copy()
                # 计算alphas[j]的上界和下界
                if LabelMat[j] != LabelMat[i]:
                    H = min(C,C + alphas[j] - alphas[i])
                    L = max(0,alphas[j] - alphas[i])
                else:
                    H = min(C,alphas[j]+alphas[i])
                    L = max(0,alphas[j]+alphas[i]-C)
                # 如果 L == H，则跳过本次循环
                if L == H:
                    print("L == H")
                    continue
                # 计算alphas[j]的公式的分母，公式见正文
                eta = dataMatrix[i,:]*dataMatrix[i,:].T + dataMatrix[j,:]*dataMatrix[j,:].T \
                      -2.0*dataMatrix[i,:]*dataMatrix[j,:].T
                # 分母不能为0，否则跳过本次循环
                if eta ==0:
                    print("eta == 0")
                    continue
                # 计算第二个变量alphas[j]的值
                alphas[j] += LabelMat[j]*(Ei - Ej)/eta
                # 判断alphas[j]的值是否超过了其上界和下界
                alphas[j] = clipAlpha(alphas[j],H,L)
                # 如果本次更新的alphas[j]变化太小，则跳过本次循环
                if (abs(alphas[j] - alphaJold)) < 0.00001:
                    print("j not moving enough !")
                    continue
                # 根据alphas[j]去求解alphas[i]
                alphas[i] += LabelMat[i]*LabelMat[j]*(alphaJold - alphas[j])
                # 更新b值
                b1 = - Ei - LabelMat[i]*(alphas[i] - alphaIold)*(dataMatrix[i,:]*dataMatrix[i,:].T)\
                     -LabelMat[j]*(alphas[j] - alphaJold)*(dataMatrix[j,:]*dataMatrix[i,:].T) + b
                b2 = - Ej - LabelMat[i]*(alphas[i] - alphaIold)*(dataMatrix[i,:]*dataMatrix[j,:].T)\
                     - LabelMat[j]*(alphas[j] - alphaJold)*(dataMatrix[j,:]*dataMatrix[j,:].T) + b
                if alphas[i] > 0 and alphas[i] < C:
                    b = b1
                elif alphas[j] > 0 and alphas[j] < C:
                    b = b2
                else:
                    b = (b1+b2)/2.0
                alphaPairsChanged +=1
                print("iter:{0};i:{1};alpha pair changed:{2}".format(iter,i,alphaPairsChanged))
        # 如果这两个向量都不能被优化，增加迭代次数
        if (alphaPairsChanged == 0):
            iter +=1
        else:
            iter = 0
        print("iteration number:%d" % iter)
    return b,alphas

有一个地方需要理解：alphaIold = alphas[i].copy() 和 alphaJold = alphas[j].copy()
为什么要用.copy()?
这里就要说到python中的浅拷贝，详细介绍见https://blog.csdn.net/weixin_40238600/article/details/93603747
如果使用直接复制的话，alphas[j]或alphas[i]一旦更新，alphaIold和alphaJold也会随之而改变。

# 计算权重系数w
def clacW(alphas,dataArr,LabelArr):
    dataMat = mat(dataArr);labelMat = mat(LabelArr).transpose()
    m,n = shape(dataMat)
    w = zeros((n,1))
    for i in range(m):
        w += multiply(alphas[i]*labelMat[i],dataMat[i,:].T)
    return w

拟合曲线

def plotBestFit(alphas,dataArr,labelArr,b):
    dataMat,labelMat = loadDataSet('testSet.txt')
    dataArr = array(dataMat)
    # 返回的是dataArr的行数
    n = shape(dataArr)[0]
    xcord1 = [];ycord1 = []
    xcord2 = [];ycord2 = []
    for i in range(n):
        if (labelArr[i] == 1):
            xcord1.append(dataArr[i,0]);ycord1.append(dataArr[i,1])
        else:
            xcord2.append(dataArr[i,0]);ycord2.append(dataArr[i,1])
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xcord1,ycord1,s = 30,c = 'red',marker = 's')
    ax.scatter(xcord2,ycord2,s = 30,c = 'green')
    x =arange(2.0,6.0,0.1)
    w = clacW(alphas, dataArr, labelArr)
    print(type(b))
    print(type(w))
    print(type(x))
    y = (-b - w[0]* x) / w[1]  # 由w1*x1+w2*x2+b=0得到x2(即y)=(-b-w1x1)/w2
    ax.plot(x,y)
    plt.xlabel('x1');plt.ylabel('x2')
    plt.show()

结果报错：

原因是：b的类型

应该改成数组：y = (-array(b)[0] - w[0] x) / w[1]
主函数运行：

if  __name__ == '__main__':
    dataArr,labelArr = loadDataSet('testSet.txt')
    b,alphas= smoSimple(dataArr, labelArr, 0.6, 0.001, 40)
    plotBestFit(alphas,dataArr,labelArr,b)

参考资料：
1.《统计学习方法》李航
2.《机器学习实战》Peter Harrington
3.【机器学习】支持向量机原理（四）SMO算法原理：https://blog.csdn.net/made_in_china_too/article/details/79547296
4.终端中光标的模式与操作：https://blog.csdn.net/Jeffxu_lib/article/details/84759961
5.[latex] 长公式换行：https://blog.csdn.net/solidsanke54/article/details/45102397
6.LaTeX大括号用法：https://blog.csdn.net/l740450789/article/details/49487847
7.机器学习实战 简化SMO算法 对第一个alpha选择条件的解读：https://blog.csdn.net/sky_kkk/article/details/79535060