SVM支持向量机-核函数python实现

参考链接：

https://blog.csdn.net/BIT_666/article/details/80012128

导入相关库

导入与我们数据处理有关的库并进行绘图的格式设置

import matplotlib as mpl
import matplotlib.pyplot as plt
from numpy import *
from time import sleep

%matplotlib inline
plt.rcParams['figure.figsize'] = (10.0, 8.0) 
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
%load_ext autoreload
%autoreload 2

查看数据集格式

filename = 'testSetRBF.txt'
fr = open(filename)
X1 = [];y1 = []
X2 = [];y2 = []
for line in fr.readlines():
    lineArr = line.strip().split(',')
    if float(lineArr[-1]) == 1:
        X1.append(float(lineArr[0]))
        y1.append(float(lineArr[1]))
    elif float(lineArr[-1]) == -1:
        X2.append(float(lineArr[0]))
        y2.append(float(lineArr[1]))   

# 使用matplotlib来绘制点图
plt.scatter(X1[:],y1[:],c='r',s=50)
plt.scatter(X2[:],y2[:],c='b',s=50)
plt.show()

​

​

定义数据读取

def loadDataSet(fileName):
    '''
    根据一定的格式来读取我们的数据
    '''
    # 数据
    dataMat = []
    # 标签
    labelMat = []
    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]))
    return dataMat,labelMat

随机选择J

selectJrand函数根据i，选择与i不同的角标作为另一个alpha的角标.

def selectJrand(i,m):
    j=i #希望alpha的标号不同
    while (j==i):
        j = int(random.uniform(0,m))
    return j 

调整Alpha

根据不同的yi，调整alphaj的范围，使其在H和L之间.

def clipAlpha(aj, H, L):
    if aj > H: 
        aj = H
    if L > aj:
        aj = L
    return aj

转换核函数

使用五种核函数，在获取数据集的情况下，实现数据转核矩阵.一会针对上述数据集，我们可以看到对于这样线性不可分的数据集，采用lin线性核的效果将大打折扣，而高斯核，拉普拉斯核的效果比较满意.

def kernelTrans(X, A, kTup): #通过数据计算转换后的核函数
    m,n = shape(X)
    K = mat(zeros((m,1)))
    if kTup[0]=='lin':   #线性核函数
        K = X * A.T   
        
    elif kTup[0]=='rbf':  #高斯核
        for j in range(m):
            deltaRow = X[j,:] - A
            K[j] = deltaRow*deltaRow.T
        K = exp(K/(-1*kTup[1]**2)) 
 
    elif kTup[0] == 'laplace':  #拉普拉斯核
        for j in range(m):
            deltaRow = X[j,:] - A
            K[j] = deltaRow*deltaRow.T
            K[j] = sqrt(K[j])
        K = exp(-K/kTup[1])     
 
    elif kTup[0] == 'poly':  #多项式核
        K = X * A.T
        for j in range(m):
            K[j] = K[j]**kTup[1]
        
    elif kTup[0] == 'sigmoid':  #Sigmoid核
        K = X * A.T
        for j in range(m):
            K[j] = tanh(kTup[1]*K[j]+kTup[2])
        
    else: 
        raise NameError('执行过程出现问题 -- 核函数无法识别')
    return K

数据结构

为了算法的一致性与简洁性，这里定义了数据结构,之后的函数调用都采用以上的数据结构，从而提高了效率.

class optStruct:
    
    def __init__(self, dataMatIn, classLabels, C, toler, kTup):  # Initialize the structure with the parameters 
        self.X = dataMatIn  # 训练数据
        self.labelMat = classLabels  # 训练类标
        self.C = C  # 常数
        self.tol = toler  # 容错率
        self.m = shape(dataMatIn)[0]  # 数据数目
        self.alphas = mat(zeros((self.m,1)))  # 初始化alpha为0
        self.b = 0
        self.eCache = mat(zeros((self.m,2))) #first column is valid flag
        self.K = mat(zeros((self.m,self.m)))  # 初始化核矩阵
        # 核矩阵
        for i in range(self.m):
            self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)

计算误差E

这里根据公式E = f(xi) - yi ，负责计算误差E.

def calcEk(oS, k):
    fXk = float(multiply(oS.alphas,oS.labelMat).T*oS.K[:,k] + oS.b)
    Ek = fXk - float(oS.labelMat[k])
    return Ek

根据最大误差选取J

直观来看，KKT条件违背的程度越大，则更新变量更新后可能导致的目标函数增幅越大，所以SMO算法先选取违背KKT条件最大的变量，第二个变量的选择一个使目标函数值增长最快的变量。这里SMO采用了一种启发式，是选取的两个变量所对应的样本的间隔最大，一种直观的解释，这样的两个变量有很大的区别，与对两个相似变量更新相比，对他们更新会使目标函数值发生更大的变化.（参考西瓜书）

def selectJ(i, oS, Ei):         
    maxK = -1; maxDeltaE = 0; Ej = 0
    oS.eCache[i] = [1,Ei]  
    validEcacheList = nonzero(oS.eCache[:,0].A)[0]
    # print(validEcacheList)
    if (len(validEcacheList)) > 1:
        for k in validEcacheList:   
            if k == i: continue 
            Ek = calcEk(oS, k)
            deltaE = abs(Ei - Ek)
            if (deltaE > maxDeltaE):
                maxK = k; maxDeltaE = deltaE; Ej = Ek
        return maxK, Ej
    else:   #in this case (first time around) we don't have any valid eCache values
        j = selectJrand(i, oS.m)
        Ej = calcEk(oS, j)
    return j, Ej

更新误差E

在alpha更新后，其相对应的误差E也基于更新的alpha重新计算.

def updateEk(oS, k):
    Ek = calcEk(oS, k)
    oS.eCache[k] = [1,Ek]

SMO算法

SMO算法又称序列最小优化，是John Platt发布的的一种训练SVM的强大算法，SMO算法的思想是将大的优化问题转换为多个小优化问题，这些小的优化往往很容易求解，并且对他们进行顺序求解和作为整体求解的结果是完全一致的。SMO算法的目标是求出一些列alpha和b，一旦求出alpha，我们的超平面w的系数便得到，我们就可以利用超平面来进行分类了。SMO算法的思想是将大的优化问题转换为多个小优化问题，这些小的优化往往很容易求解，并且对他们进行顺序求解和作为整体求解的结果是完全一致的。SMO算法的目标是求出一些列alpha和b，一旦求出alpha，我们的超平面w的系数便得到，我们就可以利用超平面来进行分类了。

SMO算法的工作原理是每次循环中选择两个alpha进行优化，先选择一个αi，然后固定αi之外的其他参数，求αi上的极值，由于存在零和约束，所以修改αi时，我们也需要修改一个αj，所以我们选择两个变量αi，αj进行优化，并固定其他参数，在参数初始化后，SMO不断执行下列两个步骤直到收敛：

·选取一对需要更新的αi，αj

·固定αi，αj之外的参数，求解获得新的αi，αj

首先在不满足KKT条件的集合中选取αi，αj，其次SMO采取了一种启发式，使选取的两变量对应的间隔越大越好，直观的解释是，这两个变量有很大的差别，与对两个相似的变量进行更新对比，对他们更新会带给目标函数值更大的变化。

def innerL(i, oS, verbose=True):
    Ei = calcEk(oS, i)
    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)):
        j, Ej = selectJ(i, oS, Ei) 
        alphaIold = oS.alphas[i].copy(); alphaJold = oS.alphas[j].copy();
        if (oS.labelMat[i] != oS.labelMat[j]):
            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: 
            if verbose:
                print("L==H")
            return 0
        eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j] 
        if eta >= 0:
            if verbose:
                print("eta>=0")
            return 0
        oS.alphas[j] -= oS.labelMat[j]*(Ei - Ej)/eta
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)
        updateEk(oS, j) 
        if (abs(oS.alphas[j] - alphaJold) < 0.00001): 
            if verbose:
                print("j not moving enough")
            return 0
        oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
        updateEk(oS, i) 
        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]) and (oS.C > oS.alphas[i]): 
            oS.b = b1
        elif (0 < oS.alphas[j]) and (oS.C > oS.alphas[j]): 
            oS.b = b2
        else: 
            oS.b = (b1 + b2)/2.0
        return 1
    else: 
        return 0

核函数选择并计算参数alpha，b

根据输入的数据集，标签，松弛因子C，容忍度toler，最大迭代数与核函数参数，运行完整的SMO算法，直到更新达到一定条件（达到迭代最大次数，更新程度达到一定变化范围），停止迭代，返回参数alpha，b.

def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup=('rbf', 1.3), verbose=True):    
    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, verbose)
                if verbose:
                    print ("fullSet, iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged))
            iter += 1
        else:
            nonBoundIs = nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i,oS, verbose)
                if verbose:
                    print ("non-bound, iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged))
            iter += 1
        if entireSet: 
            entireSet = False 
        elif (alphaPairsChanged == 0): 
            entireSet = True 
        if verbose:
            print ("iteration number: %d" % iter)
    return oS.b,oS.alphas

计算系数W

通过上一个函数返回的alpha，b，通过拉格朗日法推出的w公式，计算w

def calculateW(alphas,dataArr,labelArr):
    alphas, dataMat, labelMat = array(alphas), array(dataArr), array(labelArr)
    sum = 0
    for i in range(shape(dataMat)[0]):
        sum += alphas[i]*labelMat[i]*dataMat[i].T
    print(sum)
    return sum

测试函数

这里选择参数sigma=2，rbf 高斯核函数对之前的线性不可分点进行分类，根据预测标签与真实标签的判别，计算分类的错误率.这里可以修改核函数参数，选择不同的核函数看看支持向量机的性能表现.

def testRbf(trainData, testData, kernel, k1=1.3, verbose=True):
    '''
    测试支持向量机性能
    trainData: 训练数据文件
    testData: 测试数据文件
    '''
    # 加载数据
    dataArr, labelArr = loadDataSet(trainData)
    # 得到参数alpha和b
    b, alphas = smoP(dataArr, labelArr, 200, 0.0001, 10000, (kernel, k1), verbose=verbose) 
    
    # 生成对应的数据矩阵
    datMat = mat(dataArr)
    labelMat = mat(labelArr).transpose()
    
    svInd = nonzero(alphas.A>0)[0]
    sVs = datMat[svInd] 
    labelSV = labelMat[svInd]
    
    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,:],(kernel, k1))
        predict=kernelEval.T * multiply(labelSV,alphas[svInd]) + b
 
 
        if sign(predict)!=sign(labelArr[i]): errorCount += 1
    print("the training error rate is: %f" % (float(errorCount)/m))
    
    dataArr,labelArr = loadDataSet(testData)
    errorCount = 0
    datMat=mat(dataArr); labelMat = mat(labelArr).transpose()
    m,n = shape(datMat)
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],(kernel, k1))
        predict=kernelEval.T * multiply(labelSV,alphas[svInd]) + b
        if sign(predict)!=sign(labelArr[i]): errorCount += 1    
    print("the test error rate is: %f" % (float(errorCount)/m))

标记支持向量

通过KKT条件，寻找alpha大于0的alpha作为支持向量，然后将对应点标记.

def plot_point(filename,alphas,dataMat):
    filename = filename
    fr = open(filename)
    X1 = [];y1 = []
    X2 = [];y2 = []
    for line in fr.readlines():
        lineArr = line.strip().split(',')
        if float(lineArr[-1]) == 1:
            X1.append(float(lineArr[0]))
            y1.append(float(lineArr[1]))
        elif float(lineArr[-1]) == -1:
            X2.append(float(lineArr[0]))
            y2.append(float(lineArr[1]))
    plt.scatter(X1[:],y1[:],c='y',s=50)
    plt.scatter(X2[:],y2[:],c='b',s=50)
 
    for i, alpha in enumerate(alphas):
        if abs(alpha) > 0:
            x, y = dataMat[i]
            #plt.scatter(x, y, s=100, c = '', alpha=0.5, linewidth=1.5, edgecolor='red')
            plt.scatter(x, y, s=100, alpha=0.5, linewidth=1.5, edgecolor='red')
 
    plt.show()

主函数

第一行读取数据，第二行根据参数计算alpha，b，第三行计算错误率，第四行标记支撑向量，最后一行计算W.

rbf高斯核，k=1.3

import time

if __name__ == "__main__":
    dataArr,labelArr = loadDataSet('testSetRBF.txt')
    b,alphas = smoP(dataArr, labelArr, 0.6, 0.001, 40, verbose=False)
    start = time.time()
    testRbf(trainData='testSetRBF.txt', testData='testSetRBF2.txt', kernel='rbf', verbose=False) 
    end = time.time()
    print('time cost:',end-start,'s')
    plot_point('testSetRBF.txt',alphas,dataArr)
    calculateW(alphas,dataArr,labelArr)

there are 20 Support Vectors
the training error rate is: 0.050000
the test error rate is: 0.040000
time cost: 0.3361325263977051 s

[-0.2837046 -0.4820352]

lapalace拉普拉斯核，k=1.3

if __name__ == "__main__":
    dataArr,labelArr = loadDataSet('testSetRBF.txt')
    b,alphas = smoP(dataArr, labelArr, 0.6, 0.001, 40, kTup=('laplace', 1.3), verbose=False)
    start = time.time()
    testRbf(trainData='testSetRBF.txt', testData='testSetRBF2.txt', kernel='laplace', verbose=False) 
    end = time.time()
    print('time cost:',end-start,'s') 
    plot_point('testSetRBF.txt',alphas,dataArr)
    calculateW(alphas,dataArr,labelArr)

there are 30 Support Vectors
the training error rate is: 0.000000
the test error rate is: 0.060000
time cost: 0.47074198722839355 s

[-0.436887  -0.9289236]

linear核

if __name__ == "__main__":
    dataArr,labelArr = loadDataSet('testSetRBF.txt')
    b,alphas = smoP(dataArr,labelArr,0.6,0.001,40,kTup=('lin',1.3), verbose=False)
    start = time.time()
    testRbf(trainData='testSetRBF.txt', testData='testSetRBF2.txt', kernel='lin', verbose=False) 
    end = time.time()
    print('time cost:',end-start,'s') 
    plot_point('testSetRBF.txt',alphas,dataArr)
    calculateW(alphas,dataArr,labelArr)

there are 65 Support Vectors
the training error rate is: 0.380000
the test error rate is: 0.420000
time cost: 1.2347300052642822 s

[-0.4637016 -0.160638 ]