机器学习-支持向量机（SVM）

最新推荐文章于 2023-07-14 17:06:14 发布

库里不会写代码

最新推荐文章于 2023-07-14 17:06:14 发布

阅读量2.3k

点赞数 1

文章标签：人工智能

本文链接：https://blog.csdn.net/m0_52053228/article/details/128293423

版权

支持向量机（英文名为support vector machine，故一般简称SVM）是一类按监督学习方式对数据进行二元分类的广义线性分类器，其决策边界是对学习样本求解的最大边距超平面，可以将问题化为一个求解凸二次规划的问题。与逻辑回归和神经网络相比，支持向量机，在学习复杂的非线性方程时提供了一种更为清晰，更加强大的方式。

通俗来讲，所谓支持向量机是一种分类器，对于做出标记的两组向量，给出一个最优分割超曲面把这两组向量分割到两边，使得两组向量中离此超平面最近的向量（即所谓支持向量）到此超平面的距离都尽可能远。

一、前提

在介绍SVM之前，先解释几个概念。考虑下图共4个方框中的数据点分布，一个问题就是，能否画出一条直线将圆形点和方形点分开呢？

先考虑图A中的两组数据，它们之间已经分隔得足够开，因此很容易就可以在图中画出一条直线将两组数据点分开。在这种情况下，这组数据被称为线性可分（linearly separable）数据。

上述将数据集分隔开来的直线称为分隔超平面（separating hyperplane）。如果所给的数据集是三维的，那么此时用来分隔数据的就是一个平面。

显而易见，更高维的情况可以以此类推。如果数据集是N维的，那么就需要一个N-1维的某某对象来对数据进行分隔。这个对象就被称为超平面（hyperplane），也就是分类的决策边界。

支持向量（supp vector）就是距离分隔超平面最近的那些点。接下来要试着最大化支持向量到分隔面的距离，需要找到此问题的优化求解方法。

A框中给出了一个线性可分的数据集，B、C、D框中各自给出了一条可以将两类数据分开的直线，问题就是找出那条最优的直线。

二、寻找最大间隔

如何求解数据集的最佳分隔直线？分隔超平面的形式可以写成 $\omega ^{T}x+b$ 。要计算点A到分隔超平面的距离，就必须给出点到分隔面的法线或垂线的长度，该值为 $\frac{\left | \omega ^{T}x+b \right |}{\left \| \omega \right \|}$ 。这里的常熟b类似于Logistic回归中的截距 $w_{0}$ 。这里的向量w和常数b一起描述了所给数据的分割线或超平面。

几何距离

假设划分超平面的线性方程为： $w ^{T}x+b=0$ ，其中 $w=(w_{1},w_{2},...,w_{n})$ 为法向量，决定了超平面的方向； $b$ 为位移项，决定了超平面与源点之间的距离。显然划分超平面可被法向量 $w$ 和位移 $b$ 决定。

样本到超平面 $w ^{T}x+b=0$ 的距离： $r=\frac{\left | w ^{T}x_{i}+b \right |}{\left \| w \right \|}=\frac{y_{i}(w ^{T}x_{i}+b)}{\left \| w \right \|}$

样本集到超平面 $w ^{T}x+b=0$ 的距离： $\rho =\min_{(x_{i},y_{i})\epsilon S}\frac{y_{i}(w ^{T}x_{i}+b)}{\left \| w \right \|}=\frac{a}{\left \| w \right \|}$

优化目标： $\underset{w,b}{max}\, \, \frac{a}{||w||}\, \, \, s.t.\, \, \, y_i(w^Tx_i+b)\geqslant a,\forall i$

令 $\hat{w}=\frac{w}{a},\hat{b}=\frac{b}{a}$ ，则；

优化目标转变： $\underset{w,b}{max}\frac{1}{||\hat{w}||}\, \, \,\, \, \, s.t.\, \, \, y_{i}(\hat{w}^{T}x_{i}+\hat{b})\geqslant 1,\, \, \, \forall i$

转变后的目标函数不会影响模型的预测性能：

$h(x)=sgn(w^Tx+b)=sgn(a \hat{w}^Tx+a\hat{b})=sgn(\hat{w}^Tx+\hat{b})\cong \hat{h}(x)(a>0)$

为后续求导方便，改进为：

$\underset{w,b}{max}\frac{2}{||\hat{w}||}\, \, \,\, \, \, s.t.\, \, \, y_{i}(\hat{w}^{T}x_{i}+\hat{b})\geqslant 1,\, \, \, \forall i$

解释：求的最大值等同于求解的最大值。

假设超平面 $w ^{T}x+b=0$ 能将训练样本正确分类，取 $a=1$ ，对于 $(x_{i}, y_{i})\in D$ ，则有：

$\left\{\begin{matrix} w^{T}x_{i}+b\geqslant +1, y=+1 & & \\ w^{T}x_{i}+b\leqslant -1, y=-1 \end{matrix}\right.$

距离超平面最近的这几个训练样本点是的上述不等式中等号可以成立，被称为支持向量，两个异类支持向量到超平面距离之和为 $\frac{2}{||\hat{w}||}$ 。

最大化间隔（为了方便后续用 $w$ 当做 $\hat{w}$ ）

因此最大化间隔问题就是求解一个凸二次规划问题：

$\underset{w,b}{max}\frac{2}{||w||}\, \, \,\, \, \, s.t.\, \, \, y_{i}(w^{T}x_{i}+b)\geqslant 1,\, \, \, i=1,2,...,n$

显然，为了最大化间隔，仅需要最大化 $||w||^{-1}$ ，这等价于最小化 $||w||^{2}$ 。于是上式可写为：

$\underset{w,b}{min}\frac{1}{2}||w||^{2}\, \, \,\, \, \, s.t.\, \, \, y_{i}(w^{T}x_{i}+b)\geqslant 1,\, \, \, i=1,2,...,n$

这就是支持向量机的基本型。

三、对偶问题

求解这一优化问题的方法与求解线性问题最优分类面时所用的方法几乎相同，都是转换为一个二次函数极值问题，只是在凸二次规划中条件变为： $0\leqslant \alpha_i\leqslant C, i=1,2,...,n$ 。

定义拉格朗日函数：

$L(w,b,\alpha ,\varepsilon ,\beta )=\frac{1}{2}||w||^2+C\sum_{i=1}^{n}\varepsilon_i +\sum_{i=1}^{n}\alpha_i[1-\varepsilon_i-y_i(w^Tx_i+b)]-\sum_{i=1}^{n}\beta_i\varepsilon_i$

其中 $\alpha_i\geqslant 0,\beta_i \geqslant 0$ 是拉格朗日乘子。

令 $L(w,b,\alpha ,\varepsilon ,\beta )$ 对 $w,b,\varepsilon$ 求偏导为0可得：

$\frac{\partial L}{\partial w}=0\rightarrow w=\sum_{i=1}^{n}\alpha_iy_ix_i$

$\frac{\partial L}{\partial b}=0\rightarrow \sum_{i=1}^{n}a_iy_i=0$

$\frac{\partial L}{\partial \varepsilon }=0\rightarrow C=\alpha_i+\beta_i$

带入拉格朗日函数，可以消除 $w,b$ ，再消去 $\beta_i$ 得到对偶问题：

$L(w,b,\alpha ,\varepsilon ,\beta )=\frac{1}{2}||w||^2+C\sum_{i=1}^{n}\varepsilon_i +\sum_{i=1}^{n}\alpha_i[1-\varepsilon_i-y_i(w^Tx_i+b)]-\sum_{i=1}^{n}\beta_i\varepsilon_i$

$=\frac{1}{2}||w||^2+\sum_{i=1}^{n}\alpha_i[1-y_i(w^Tx_i+b)]+C\sum_{i=1}^{n}\varepsilon_i -\sum_{i=1}^{n}\alpha_i\varepsilon_i-\sum_{i=1}^{n}\beta_i\varepsilon_i$

$=\frac{1}{2}w^Tw+\sum_{i=1}^{n}\alpha_i-\sum_{i=1}^{n}a_iy_iw^Tx_i-\sum_{i=1}^{n}a_iy_ib+C\sum_{i=1}^{n}\varepsilon_i -\sum_{i=1}^{n}\alpha_i\varepsilon_i-\sum_{i=1}^{n}\beta_i\varepsilon_i$

$=\frac{1}{2}w^T\sum_{i=1}^{n}a_iy_ix_i-w^T\sum_{i=1}^{n}a_iy_ix_i+\sum_{i=1}^{n}\alpha_i-b\sum_{i=1}^{n}a_iy_i+C\sum_{i=1}^{n}\varepsilon_i -\sum_{i=1}^{n}\alpha_i\varepsilon_i-\sum_{i=1}^{n}\beta_i\varepsilon_i$

$=-\frac{1}{2}\sum_{i=1}^{n}a_iy_ix_i^T\sum_{i=1}^{n}a_iy_ix_i+\sum_{i=1}^{n}\alpha_i-b\sum_{i=1}^{n}a_iy_i+C\sum_{i=1}^{n}\varepsilon_i -\sum_{i=1}^{n}\alpha_i\varepsilon_i-\sum_{i=1}^{n}\beta_i\varepsilon_i$

$=-\frac{1}{2}\sum_{i=1}^{n}a_iy_ix_i^T\sum_{i=1}^{n}a_iy_ix_i+\sum_{i=1}^{n}\alpha_i+C\sum_{i=1}^{n}\varepsilon_i -\sum_{i=1}^{n}\alpha_i\varepsilon_i-\sum_{i=1}^{n}\beta_i\varepsilon_i$

$=-\frac{1}{2}\sum_{i=1}^{n}a_iy_ix_i^T\sum_{i=1}^{n}a_iy_ix_i+\sum_{i=1}^{n}\alpha_i+(C-\alpha_i-\beta_i)\sum_{i=1}^{n}\varepsilon_i$

$=\sum_{i=1}^{n}\alpha_i-\frac{1}{2}\sum_{i=1}^{n}\sum_{j=1}^{n}\alpha _i\alpha _jy_iy_jx_i^Tx_j$

对偶问题：

$\underset{\alpha }{max}\sum_{i=1}^{n}\alpha_i-\frac{1}{2}\sum_{i=1}^{n}\sum_{j=1}^{n}\alpha _i\alpha _jy_iy_jx_i^Tx_j$

$s.t.\: \: \: \sum_{i=1}^{n}a_iy_i=0$

$0< \alpha < C,i=1,2,...,n$

假设 $\alpha ^{*}$ 是上面凸二次规划问题的最优解，则 $\alpha ^{*}\neq 0$ 。假设满足 $\alpha ^{*}>0$ ，按下面方式计算出的解为原问题的唯一最优解：

$w^*=\sum_{i=1}^{n}\alpha_i^{*}y_ix_i$

在KKT条件下我们希望带入一个支持向量的值来求出 $b^*$ ，但是求解b的值需要 $\varepsilon$ 的帮助而想要求出 $\varepsilon$ 的值需要 $b^*$ 的帮助这样的话就形成了死锁什么值都求不出来。恰好我们有另外一个条件的支撑向量（ $\alpha \leqslant C$ 的情况下，称之为自由支持向量），这种支持向量的 $\varepsilon$ 值为0。这样我们可以利用自由支持向量来求出 $b^*$ 的值。

$0< \alpha^* < C$ ：这时 $\varepsilon$ 的值为0，可以通过下式计算 $b^*=y_i-\sum_{i=1}^{n}\alpha_i^*y_ix_i^Tx_i$ 。
$\alpha^*=0$ ：不是支持向量机，无法计算。
$\alpha^* =C$ ：这个时候 $b^*=y_i-\sum_{i=1}^{n}\alpha_i^*y_ix_i^Tx_i-\varepsilon_i$ ，求解 $b^*$ 需要 $\varepsilon$ ，产生死锁。

四、代码实现

from numpy import * 
import matplotlib.pyplot as plt

from pylab import mpl
# 设置显示中文字体
mpl.rcParams["font.sans-serif"] = ["SimHei"]
# 设置正常显示符号
mpl.rcParams["axes.unicode_minus"] = False

def loadDataSet(filename): # 读取数据
    dataMat = []
    labelMat = []
    data1 = []
    data2 = []
    data3 = []
    data4 = []
    fr = open(filename)
    for line in fr.readlines():
        lineArr = line.strip().split(' ')
        dataMat.append([float(lineArr[0]),float(lineArr[1])])
        labelMat.append(float(lineArr[2]))

        lineArr[0] = float(lineArr[0])
        lineArr[1] = float(lineArr[1])
        lineArr[2] = float(lineArr[2])
        if lineArr[2] == 1:
            data1.append((lineArr[0]))
            data2.append((lineArr[1]))
        else:
            data3.append((lineArr[0]))
            data4.append((lineArr[1]))
    x_1 = data1
    y_1 = data2
    x_2 = data3
    y_2 = data4
    colors1 = '#00CED1'
    colors2 = '#DC143C'
    plt.scatter(x_1, y_1, c=colors1, label='有奖学金')
    plt.scatter(x_2, y_2, c=colors2, label='无奖学金')
    plt.legend()
    plt.grid("on")
    plt.show()
    return dataMat, labelMat # 返回数据特征和数据类别

def selectJrand(i,m): #在0-m中随机选择一个不是i的整数
    j=i
    while (j==i):
        j=int(random.uniform(0,m))
    return j

def clipAlpha(aj,H,L):  #保证a在L和H范围内（L <= a <= H）
    if aj>H:
        aj=H
    if L>aj:
        aj=L
    return aj

def kernelTrans(X, A, kTup): #核函数，输入参数,X:支持向量的特征树；A：某一行特征数据；kTup：('lin',k1)核函数的类型和参数
    m,n = shape(X)
    K = mat(zeros((m,1)))
    if kTup[0]=='lin': #线性函数
        K = X * A.T
    elif kTup[0]=='rbf': # 径向基函数(radial bias function)
        for j in range(m):
            deltaRow = X[j,:] - A
            K[j] = deltaRow*deltaRow.T
        K = exp(K/(-1*kTup[1]**2)) #返回生成的结果
    else:
        raise NameError('Houston We Have a Problem -- That Kernel is not recognized')
    return K


#定义类，方便存储数据
class optStruct:
    def __init__(self,dataMatIn, classLabels, C, toler, kTup):  # 存储各类参数
        self.X = dataMatIn  #数据特征
        self.labelMat = classLabels #数据类别
        self.C = C #软间隔参数C，参数越大，非线性拟合能力越强
        self.tol = toler #停止阀值
        self.m = shape(dataMatIn)[0] #数据行数
        self.alphas = mat(zeros((self.m,1)))
        self.b = 0 #初始设为0
        self.eCache = mat(zeros((self.m,2))) #缓存
        self.K = mat(zeros((self.m,self.m))) #核函数的计算结果
        for i in range(self.m):
            self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)


def calcEk(oS, k): #计算Ek（参考《统计学习方法》p127公式7.105）
    fXk = float(multiply(oS.alphas,oS.labelMat).T*oS.K[:,k] + oS.b)
    Ek = fXk - float(oS.labelMat[k])
    return Ek

#随机选取aj，并返回其E值
def selectJ(i, oS, Ei):
    maxK = -1
    maxDeltaE = 0
    Ej = 0
    oS.eCache[i] = [1,Ei]
    validEcacheList = nonzero(oS.eCache[:,0].A)[0]  #返回矩阵中的非零位置的行数
    if (len(validEcacheList)) > 1:
        for k in validEcacheList:
            if k == i:
                continue
            Ek = calcEk(oS, k)
            deltaE = abs(Ei - Ek)
            if (deltaE > maxDeltaE): #返回步长最大的aj
                maxK = k
                maxDeltaE = deltaE
                Ej = Ek
        return maxK, Ej
    else:
        j = selectJrand(i, oS.m)
        Ej = calcEk(oS, j)
    return j, Ej


def updateEk(oS, k): #更新os数据
    Ek = calcEk(oS, k)
    oS.eCache[k] = [1,Ek]

#首先检验ai是否满足KKT条件，如果不满足，随机选择aj进行优化，更新ai,aj,b值
def innerL(i, oS): #输入参数i和所有参数数据
    Ei = calcEk(oS, i) #计算E值
    if ((oS.labelMat[i]*Ei < -oS.tol) and (oS.alphas[i] < oS.C)) or ((oS.labelMat[i]*Ei > oS.tol) and (oS.alphas[i] > 0)): #检验这行数据是否符合KKT条件 参考《统计学习方法》p128公式7.111-113
        j,Ej = selectJ(i, oS, Ei) #随机选取aj，并返回其E值
        alphaIold = oS.alphas[i].copy()
        alphaJold = oS.alphas[j].copy()
        if (oS.labelMat[i] != oS.labelMat[j]): #以下代码的公式参考《统计学习方法》p126
            L = max(0, oS.alphas[j] - oS.alphas[i])
            H = min(oS.C, oS.C + oS.alphas[j] - oS.alphas[i])
        else:
            L = max(0, oS.alphas[j] + oS.alphas[i] - oS.C)
            H = min(oS.C, oS.alphas[j] + oS.alphas[i])
        if L==H:
            print("L==H")
            return 0
        eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j] #参考《统计学习方法》p127公式7.107
        if eta >= 0:
            print("eta>=0")
            return 0
        oS.alphas[j] -= oS.labelMat[j]*(Ei - Ej)/eta #参考《统计学习方法》p127公式7.106
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L) #参考《统计学习方法》p127公式7.108
        updateEk(oS, j)
        if (abs(oS.alphas[j] - alphaJold) < oS.tol): #alpha变化大小阀值（自己设定）
            print("j not moving enough")
            return 0
        oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])#参考《统计学习方法》p127公式7.109
        updateEk(oS, i) #更新数据
        #以下求解b的过程，参考《统计学习方法》p129公式7.114-7.116
        b1 = oS.b - Ei- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,i] - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[i,j]
        b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,j]- oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j]
        if (0 < oS.alphas[i]<oS.C):
            oS.b = b1
        elif (0 < oS.alphas[j]<oS.C):
            oS.b = b2
        else:
            oS.b = (b1 + b2)/2.0
        return 1
    else:
        return 0


#SMO函数，用于快速求解出alpha
def smoP(dataMatIn, classLabels, C, toler, maxIter,kTup=('lin', 0)): #输入参数：数据特征，数据类别，参数C，阀值toler，最大迭代次数，核函数（默认线性核）
    oS = optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,toler, kTup)
    iter = 0
    entireSet = True
    alphaPairsChanged = 0
    while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):
        alphaPairsChanged = 0
        if entireSet:
            for i in range(oS.m): #遍历所有数据
                alphaPairsChanged += innerL(i,oS)
                print("fullSet, iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged)) #显示第多少次迭代，那行特征数据使alpha发生了改变，这次改变了多少次alpha
            iter += 1
        else:
            nonBoundIs = nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]
            for i in nonBoundIs: #遍历非边界的数据
                alphaPairsChanged += innerL(i,oS)
                print("non-bound, iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged))
            iter += 1
        if entireSet:
            entireSet = False
        elif (alphaPairsChanged == 0):
            entireSet = True
        print("iteration number: %d" % iter)
    return oS.b,oS.alphas

def testRbf(data_train,data_test):
    dataArr,labelArr = loadDataSet(data_train) #读取训练数据
    b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 10000, ('rbf', 1.3)) #通过SMO算法得到b和alpha
    datMat=mat(dataArr)
    labelMat = mat(labelArr).transpose()
    svInd=nonzero(alphas)[0]  #选取不为0数据的行数（也就是支持向量）
    sVs=datMat[svInd] #支持向量的特征数据
    labelSV = labelMat[svInd] #支持向量的类别（1或-1）
    print("there are %d Support Vectors" % shape(sVs)[0]) #打印出共有多少的支持向量
    m,n = shape(datMat) #训练数据的行列数
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],('rbf', 1.3)) #将支持向量转化为核函数
        predict=kernelEval.T * multiply(labelSV,alphas[svInd]) + b  #这一行的预测结果（代码来源于《统计学习方法》p133里面最后用于预测的公式）注意最后确定的分离平面只有那些支持向量决定。
        if sign(predict)!=sign(labelArr[i]): #sign函数 -1 if x < 0, 0 if x==0, 1 if x > 0
            errorCount += 1
    print("the training error rate is: %f" % (float(errorCount)/m)) #打印出错误率
    dataArr_test,labelArr_test = loadDataSet(data_test) #读取测试数据
    errorCount_test = 0
    datMat_test=mat(dataArr_test)
    labelMat = mat(labelArr_test).transpose()
    m,n = shape(datMat_test)
    for i in range(m): #在测试数据上检验错误率
        kernelEval = kernelTrans(sVs,datMat_test[i,:],('rbf', 1.3))
        predict=kernelEval.T * multiply(labelSV,alphas[svInd]) + b
        if sign(predict)!=sign(labelArr_test[i]):
            errorCount_test += 1
    print("the test error rate is: %f" % (float(errorCount_test)/m))


if __name__=='__main__':
    filename_traindata='./ch5/grade_train.txt'
    filename_testdata='./ch5/grade_test.txt'
    testRbf(filename_traindata,filename_testdata)

五、总结

优点：

支持向量机算法可以解决小样本情况下的机器学习问题，简化了通常的分类和回归等问题。
由于采用核函数方法克服了维数灾难和非线性可分的问题，所以向高维空间映射时没有增加计算的复杂性。换句话说，由于支持向量计算法的最终决策函数只由少数的支持向量所确定，所以计算的复杂性取决于支持向量的数目，而不是样本空间的维数。
支持向量机算法利用松弛变量可以允许一些点到分类平面的距离不满足原先要求，从而避免这些点对模型学习的影响。

缺点：

支持向量机算法对大规模训练样本难以实施。这是因为支持向量机算法借助二次规划求解支持向量，这其中会涉及m阶矩阵的计算，所以矩阵阶数很大时将耗费大量的机器内存和运算时间。
经典的支持向量机算法只给出了二分类的算法，而在数据挖掘的实际应用中，一般要解决多分类问题，但支持向量机对于多分类问题解决效果并不理想。
SVM算法效果与核函数的选择关系很大，往往需要尝试多种核函数，即使选择了效果比较好的高斯核函数，也要调参选择恰当的参数。另一方面就是现在常用的SVM理论都是使用固定惩罚系数C，但正负样本的两种错误造成的损失是不一样的。

库里不会写代码

关注

1
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
1
评论
机器学习-支持向量机（SVM）

支持向量机算法可以解决小样本情况下的机器学习问题，简化了通常的分类和回归等问题。由于采用核函数方法克服了维数灾难和非线性可分的问题，所以向高维空间映射时没有增加计算的复杂性。换句话说，由于支持向量计算法的最终决策函数只由少数的支持向量所确定，所以计算的复杂性取决于支持向量的数目，而不是样本空间的维数。支持向量机算法利用松弛变量可以允许一些点到分类平面的距离不满足原先要求，从而避免这些点对模型学习的影响。支持向量机算法对大规模训练样本难以实施。
复制链接

扫一扫