《机器学习实战》学习笔记第六章-支持向量机SVM

目录

支持向量机简介

序列最小优化算法SMO

加速优化的完整版 Platt SMO 算法

核函数

 SVM实现手写数字识别

---

支持向量机简介

支持向量机是线性分类器，是一种学霸方法，能最大限度分开两个类，即不仅做得对，还要保证质量

如何保证分类的正确性最大呢？

这是一个分类器求解的优化问题。

因为是线性分类器，线性不可分情况不好办。可以将当前数据引入更高维度中，运用线性超平面求解。超平面是分类的决策边界，比数据集低一维。

支持向量就是指离分隔超平面最近的那些点。

寻找最大间隔

那么，如何找到最佳决策分界面呢？以wx+b=0表示决策分界面，最大化间隔的目标就是找出分类器定义中的w和b。为此，我们必须找到具有最小间隔的数据点，而这些数据点也就是前面提到的支持向量。一旦找到具有最小间隔的数据点，我们就需要对该间隔最大化。

这是最值优化问题要求解的公式：

 直接求解上述问题相当困难，所以我们根据拉格朗日乘子法将它转换成为另一种更容易求解的形式。具体演算流程参考：

支持向量机（SVM）——原理篇 - 知乎 (zhihu.com)

svm原理从头到尾详细推导 (qq.com)

 约束条件为：

 其中常数C用于控制 “最大化间隔” 和 “保证大部分点的函数间隔小于1.0” 这两个目标的权重。在优化算法的实现代码中，常数C是一个参数，因此可以通过调节该参数得到不同的结果。一旦求出了所有的alpha，那么分隔超平面就可以通过这些alpha来表达。SVM的主要工作就是求解alpha。

因此，支持向量机方法的优缺点：

优点：强分类器，能保证最大化区分两个类别，所以模型性能优异；泛化错误率低，计算开销不大，结果易解释。

缺点：对参数调节和核函数的选择敏感，不能处理不同类别相互交融的情况，只能大致上保持正确。

适用数据类型：数值型和标称型

一般过程：

1.收集数据

2.准备数据：数值型

3.分析数据：有助于可视化分隔超平面

4.训练算法：大部分时间用于训练，主要实现两个参数的调优

5.测试算法：十分简单的计算过程

6.使用算法：几乎所有的分类问题都可以使用SVM，SVM本身是一个二类分类器，对多类问题需要做一些代码上的调整。

序列最小优化算法SMO

SMO算法的工作原理：每次循环中选择两个alpha进行优化，一旦找到一对合适的alpha，那么就增大一个同时减小另一个，这里所谓的合适是指两个alpha要符合一定的条件，条件之一是个alpha必须在间隔边界之外；第二个条件是这两个alpha还没有进行过区间化处理或者不在边界上。
简化版SMO算法：首先在数据集上遍历每一个alpha，然后再随机选择另一个，从而构成alpha对。完整版SMO算法则是同时确定要优化的最佳alpha对。同时改变两个alpha至关重要，因为我们的约束条件：

 改变一个alpha可能导致该条件失效，因此同时改变两个alpha。

辅助函数

import numpy as np
def loadDataSet(fileName):
    dataMat = []
    labelMat = []
    fr = open(fileName)
    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

def selectJrand(i,m): #i是第一个alpha的下标，m是所有alpha的数目，输出一个不等于i的j
    j=i
    while(j==i):
        j=int(np.random.uniform(0,m))
    return j

def clipAlpha(aj,H,L): #调整aj范围，介于最大值H和最小值L之间
    if aj>H:
        aj=H
    if L>aj:
        aj=L
    return aj

简化版SMO算法：

def smoSimple(dataMatIn,classLabels,C,toler,maxIter): #数据集，类别标签，常数C，容错率，退出前最大循环次数
    dataMatrix = np.mat(dataMatIn)
    labelMat = np.mat(classLabels).transpose()
    b=0
    m,n = np.shape(dataMatrix)
    alphas = np.mat(np.zeros((m,1)))#初始化alpha参数，设为0
    iter = 0 #储存在没有任何alpha改变的情况下遍历数据集的次数
    while (itertoler) and (alphas[i]>0)):
                j = selectJrand(i,m) #随机选择另一个alpha
                fxj = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[j,:].T))+b
                Ej = fxj-float(labelMat[j]) #误差Ej
                alphaIold = alphas[i].copy() #深拷贝alpha
                alphaJold = alphas[j].copy()
                if(labelMat[i]!=labelMat[j]):#如果在两侧
                    L = max(0,alphas[j]-alphas[i]) #最低是0，最大是C
                    H = min(C,C+alphas[j]-alphas[i])
                else: #如果在同侧
                    L = max(0,alphas[j]+alphas[i]-C)
                    H = min(C,alphas[j]+alphas[i])
                if L==H:
                    print('L==H');continue
                eta = 2.0 * dataMatrix[i,:]*dataMatrix[j,:].T - dataMatrix[i,:]*dataMatrix[i,:].T - dataMatrix[j,:]*dataMatrix[j,:].T #alphas[j]的最优修改量
                if eta >= 0: print("eta>=0"); continue
                #更新alpha_j
                alphas[j] -= labelMat[j]*(Ei - Ej)/eta
                #修剪alpha_j
                alphas[j] = clipAlpha(alphas[j],H,L)
                if (abs(alphas[j] - alphaJold) < 0.00001): print("alpha_j变化太小"); continue
                #更新alpha[i]
                alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
                b1 = b - Ei- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[i,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[i,:]*dataMatrix[j,:].T
                b2 = b - Ej- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[j,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[j,:]*dataMatrix[j,:].T
                if (0alphas[i]):
                    b = b1
                elif (0alphas[j]):
                    b = b2
                else:
                    b = (b1+b2)/2.0
                alphaPairsChanged+=1
                print(f'iter: {iter} i: {i} pairs changed {alphaPairsChanged}')
        if(alphaPairsChanged == 0):
            iter += 1
        else:
            iter = 0
        print(f'iteration number: {iter}')
    return b,alphas

dataArr,labelArr = loadDataSet('C06/testSet.txt')
b,alphaa = smoSimple(dataArr,labelArr,0.6,0.001,40)
print(b)

输出b在

输出图像

def showClassifer(dataMat, labelMat, w, b):
    #绘制样本点
    data_plus = []                                  #正样本
    data_minus = []                                 #负样本
    for i in range(len(dataMat)):
        if labelMat[i] > 0:
            data_plus.append(dataMat[i])
        else:
            data_minus.append(dataMat[i])
    data_plus_np = np.array(data_plus)              #转换为numpy矩阵
    data_minus_np = np.array(data_minus)            #转换为numpy矩阵
    plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1], s=30, alpha=0.7)   #正样本散点图
    plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1], s=30, alpha=0.7) #负样本散点图
    #绘制直线
    x1 = max(dataMat)[0]
    x2 = min(dataMat)[0]
    a1, a2 = w
    b = float(b)
    a1 = float(a1[0])
    a2 = float(a2[0])
    y1, y2 = (-b - a1*x1)/a2, (-b - a1*x2)/a2
    plt.plot([x1, x2], [y1, y2])
    #找出支持向量点
    for i, alpha in enumerate(alphas):
        if abs(alpha) > 0:
            x, y = dataMat[i]
            plt.scatter([x], [y], s=150, c='none', alpha=0.7, linewidth=1.5, edgecolor='red')
    plt.show()

#求W
def get_w(dataMat, labelMat, alphas):
    dataMat = np.mat(dataMat)
    labelMat = np.mat(labelMat).transpose()
    m,n = np.shape(dataMat)
    w = np.zeros((n,1))
    for i in range(m):
        w += np.multiply(alphas[i]*labelMat[i],dataMat[i,:].T)
    return w

加速优化的完整版 Platt SMO 算法

Platt SMO算法是通过一个 外循环 来选择第一个alpha值的，并且其选择过程会在两种方式之间进行交替：一种方式是在所有数据集上进行单遍扫描，另一种方式则是在非边界alpha中实现单遍扫描。而所谓非边界alpha指的就是那些不等于边界0或C的alpha值。对整个数据集的扫描相当容易，而实现非边界alpha值的扫描时，首先需要建立这些alpha值的列表，然后再对这个表进行遍历。同时，该步骤会跳过那些已知的不会改变的alpha值。

在选择第一个alpha值后，算法会通过一个 内循环 来选择第二个alpha值。在优化过程中，会通过 最大化步长 的方式来获得第二个alpha值。在简化版SMO算法中，我们会在选择j 之后计算错误率 Ej。但在这里，我们会建立一个全局的缓存用于保存误差值，并从中选择使得步长或者说 Ei-Ej 最大的alpha 值。

支持函数

class optStruct:
    def __init__(self, dataMatIn, classLabels, C, toler):#数据集，数据标签，松弛变量，容错率
        self.X = dataMatIn
        self.labelMat = classLabels
        self.C = C
        self.tol = toler
        self.m = np.shape(dataMatIn)[0]#数据行数
        self.alphas = np.mat(np.zeros((self.m,1)))#初始alpha   
        self.b = 0#初始化b参数为0
        #第一列为是否有效的标志位，第二列为实际的误差E的值。
        self.eCache = np.mat(np.zeros((self.m,2)))
#计算误差Ek
def calcEk(oS, k):#os数据结构
    fXk = float(np.multiply(oS.alphas,oS.labelMat).T*(oS.X*oS.X[k,:].T) + oS.b)
    Ek = fXk - float(oS.labelMat[k])
    return Ek
#内循环的启发方式
def selectJ(i,oS,Ei):
    maxK=-1;maxDeltaE=0;Ej=0
    oS.eCache[i]=[1,Ei]
    validEcacheList = np.nonzero(oS.eCache[:,0].A)[0]#.A矩阵变数组,nonzero得到数组array中非零元素的位置（数组索引）
    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:
        j = selectJrand(i,oS.m)
        Ej = calcEk(oS,j)
    return j,Ej
#更新Ek
def updateEk(oS,k):
    Ek = calcEk(oS,k)
    oS.eCache[k] = [1,Ek]

完整platt SMO算法中的优化例程

def innerL(i, oS):
    #计算误差Ei
    Ei = calcEk(oS, i)
    #优化alpha,设定一定的容错率
    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)):
        #使用内循环启发方式2选择alpha_j,并计算Ej
        j,Ej = selectJ(i, oS, Ei)
        #保存更新前的aplpha值，使用深拷贝
        alphaIold = oS.alphas[i].copy(); alphaJold = oS.alphas[j].copy();
        #计算上下界L和H
        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:
            print("L==H")
            return 0
        
        eta = 2.0 * oS.X[i,:] * oS.X[j,:].T - oS.X[i,:] * oS.X[i,:].T - oS.X[j,:] * oS.X[j,:].T
        if eta >= 0:
            print("eta>=0")
            return 0
        #更新alpha_j
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta
        #修剪alpha_j
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)
        #更新Ej至误差缓存
        updateEk(oS, j)
        if (abs(oS.alphas[j] - alphaJold) < 0.00001):
            print("alpha_j变化太小")
            return 0
        #更新alpha_i
        oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
        #更新Ei至误差缓存
        updateEk(oS, i)
        #更新b_1和b_2
        b1 = oS.b - Ei- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[i,:].T - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[i,:]*oS.X[j,:].T
        b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[j,:].T - oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[j,:]*oS.X[j,:].T
        #根据b_1和b_2更新b
        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是1，未优化是0

完整的线性SMO算法

def smoP(dataMatIn, classLabels, C, toler, maxIter):
    oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler)#初始化数据结构
    iter = 0#初始化当前迭代次数
    entireSet = True; alphaPairsChanged = 0
    #遍历整个数据集都alpha也没有更新或者超过最大迭代次数,则退出循环
    while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)): 
        alphaPairsChanged = 0
        if entireSet:#遍历整个数据集                           
            for i in range(oS.m):       
                alphaPairsChanged += innerL(i,oS)#使用优化的SMO算法
                print(f"全样本遍历:第{iter}次迭代 样本:{i}, alpha优化次数:{alphaPairsChanged}")
            iter += 1
        else:#遍历非边界值
            nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]#遍历不在边界0和C的alpha
            for i in nonBoundIs:
                alphaPairsChanged += innerL(i,oS)
                print(f"非边界遍历:第{iter}次迭代 样本:{i}, alpha优化次数:{alphaPairsChanged}" )
            iter += 1
        if entireSet:#遍历一次后改为非边界遍历
            entireSet = False
        elif (alphaPairsChanged == 0):#如果alpha没有更新,计算全样本遍历
            entireSet = True 
        print("迭代次数: %d" % iter)
    return oS.b,oS.alphas#返回SMO算法计算的b和alphas

输出

if __name__ == '__main__':
    dataArr,labelArr = loadDataSet('C06/testSet.txt')
    b,alphas = smoP(dataArr,labelArr, 0.6, 0.001, 40)
    w = get_w(dataArr,labelArr, alphas)
    print(w)
    showClassifer(dataArr,labelArr, w, b)

 检验数据点分类：

datMat = np.mat(dataArr)
print(datMat[2]*np.mat(w)+b)

结果是正数，label=1；负数label=-1，表明分类无误

核函数

核函数的目的主要是为了解决非线性分类问题，通过核技巧将低维的非线性特征转化为高维的线性特征，从而可以通过线性模型来解决非线性的分类问题。

 在图中，数据点处于一个圆中，人类的大脑能够意识到这一点。然而，对于分类器而言，它只能识别分类器的结果是大于0还是小于0。如果只在x和y轴构成的坐标系中插入直线进行分类的话，我们并不会得到理想的结果。但是或许可以对圆中的数据进行某种形式的转换，从而得到某些新的变量来表示数据。在这种表示情况下，我们就更容易得到大于0或者小于0的测试结果。在通常情况下，这种映射是通过 核函数 来实现的，会将低维特征空间映射到高维空间。

我们可以把核函数想象成一个 包装器（wrapper）或者是 接口（interface），它能把数据从某个很难处理的形式转换成为另一个较容易处理的形式。如果上述特征空间映射的说法听起来很让人迷糊的话，那么可以将它想象成为另外一种距离计算的方法。距离计算的方法有很多种，核函数一样具有多种类型。经过空间转换之后，我们可以在高维空间中解决线性问题，这也就等价于在低维空间中解决非线性问题。

通过核函数将数据转换到更高维空间

def kernelTrans(X,A,kTup): #数据矩阵,单个数据的向量,包含核函数信息的元组(第一个参数是描述所用核函数类型的字符串，后两个参数则是核函数用到的可选参数)
    m,n = np.shape(X)
    K = np.mat(np.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 = np.exp(K/-1*kTup[1]**2)
    else: raise NameError('核函数无法识别')
    return K

修改原函数

class optStruct:
    def __init__(self, dataMatIn, classLabels, C, toler, kTup):
        self.X = dataMatIn
        self.labelMat = classLabels
        self.C = C
        self.tol = toler
        self.m = np.shape(dataMatIn)[0]
        self.alphas = np.mat(np.zeros((self.m,1)))
        self.b = 0
        self.eCache = np.mat(np.zeros((self.m,2)))
        self.K = np.mat(np.zeros((self.m,self.m)))#初始化核函数K
        for i in range(self.m):#填充每一列
            self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)
        
def innerL(i, oS):
    #计算误差Ei
    Ei = calcEk(oS, i)
    #优化alpha,设定一定的容错率
    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)):
        #使用内循环启发方式2选择alpha_j,并计算Ej
        j,Ej = selectJ(i, oS, Ei)
        #保存更新前的aplpha值，使用深拷贝
        alphaIold = oS.alphas[i].copy(); alphaJold = oS.alphas[j].copy();
        #计算上下界L和H
        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:
            print("L==H")
            return 0
        
        eta = 2.0 * oS.K[i,j] - oS.K[i,i] - oS.K[j,j]
        if eta >= 0:
            print("eta>=0")
            return 0
        #更新alpha_j
        oS.alphas[j] -= oS.labelMat[j] * (Ei - Ej)/eta
        #修剪alpha_j
        oS.alphas[j] = clipAlpha(oS.alphas[j],H,L)
        #更新Ej至误差缓存
        updateEk(oS, j)
        if (abs(oS.alphas[j] - alphaJold) < 0.00001):
            print("alpha_j变化太小")
            return 0
        #更新alpha_i
        oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
        #更新Ei至误差缓存
        updateEk(oS, i)
        #更新b_1和b_2
        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]
        #根据b_1和b_2更新b
        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是1，未优化是0

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

def smoP(dataMatIn, classLabels, C, toler, maxIter, kTup = ('lin',0)):
    oS = optStruct(np.mat(dataMatIn), np.mat(classLabels).transpose(), C, toler, kTup)#初始化数据结构

构建核函数分类器

def testRbf(k1=1.3):
    dataArr,labelArr = loadDataSet('C06/testSetRBF.txt')#加载训练集
    b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 100, ('rbf', k1))#根据训练集计算b和alphas
    datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose()
    svInd = np.nonzero(alphas.A > 0)[0]#获得支持向量
    sVs = datMat[svInd]
    labelSV = labelMat[svInd]
    print(f"支持向量个数:{np.shape(sVs)[0]}")
    m,n = np.shape(datMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],('rbf', k1))#计算各个点的核
        predict = kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b#根据支持向量的点，计算超平面，返回预测结果
        #返回数组中各元素的正负符号，用1和-1表示，并统计错误个数
        if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1
    print(f"训练集错误率:{((float(errorCount)/m))}" )#打印错误率

    dataArr,labelArr = loadDataSet('C06/testSetRBF2.txt')#加载测试集
    errorCount = 0
    datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose()
    m,n = np.shape(datMat)
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],('rbf', k1))#计算各个点的核
        predict=kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b
        if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1
    print(f"测试集错误率:{((float(errorCount)/m))}")

if __name__ == '__main__':
    testRbf()

 可以尝试不同的K1值，经过实验会发现K1越大，过拟合越严重。支持向量的数目存在一个最优值。SVM的优点在于它能对数据进行高效分类。如果支持向量太少，就可能会得到一个很差的决策边界；如果支持向量太多，也就相当于每次都利用整个数据集进行分类，这种分类方法称为k近邻。

k=0.3时

 SVM实现手写数字识别

 借用knn转换数据类型的代码

def img2vector(filename):
    returnVect =np.zeros((1,1024))
    fr = open(filename)
    for i in range(32):
        lineStr = fr.readline()
        for j in range(32):
            returnVect[0,32*i+j] = int(lineStr[j])
    return returnVect

def loadImages(dirName):
    hwLabels = []
    trainingFileList = listdir(dirName)
    m = len(trainingFileList)
    trainingMat = np.zeros((m,1024))
    for i in range(m):
        fileNameStr = trainingFileList[i]
        fileStr = fileNameStr.split('.')[0] #提取.txt前面的名字
        classNumStr = int(fileStr.split('_')[0]) #文件名都为0_77这种，所以取_前面的数字，为图片表示数字
        if classNumStr==9:
            hwLabels.append(-1)
        else:
            hwLabels.append(1)
        trainingMat[i,:] = img2vector(f'{dirName}/{fileNameStr}')
    return trainingMat, hwLabels

def testDigis(kTup=('rbf',10)):
    dataArr,labelArr = loadImages('trainingDigits')#加载训练集
    b,alphas = smoP(dataArr, labelArr, 200, 0.0001, 10000, kTup)#根据训练集计算b和alphas
    datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose()
    svInd = np.nonzero(alphas.A > 0)[0]#获得支持向量
    sVs = datMat[svInd]
    labelSV = labelMat[svInd]
    print(f"支持向量个数:{np.shape(sVs)[0]}")
    m,n = np.shape(datMat)
    errorCount = 0
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],kTup)#计算各个点的核
        predict = kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b#根据支持向量的点，计算超平面，返回预测结果
        #返回数组中各元素的正负符号，用1和-1表示，并统计错误个数
        if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1
    print(f"训练集错误率:{((float(errorCount)/m))}" )#打印错误率

    dataArr,labelArr = loadImages('testDigits')#加载测试集
    errorCount = 0
    datMat = np.mat(dataArr); labelMat = np.mat(labelArr).transpose()
    m,n = np.shape(datMat)
    for i in range(m):
        kernelEval = kernelTrans(sVs,datMat[i,:],kTup)#计算各个点的核
        predict=kernelEval.T * np.multiply(labelSV,alphas[svInd]) + b
        if np.sign(predict) != np.sign(labelArr[i]): errorCount += 1
    print(f"测试集错误率:{((float(errorCount)/m))}")

if __name__ == '__main__':
    testDigis()

结果