机器学习实战之SVM与二分类

文章目录

一、线性SVM
- 1.1 最大间隔与分类
- 1.2 对偶问题
- 1.3 SMO算法流程
二、非线性SVM
- 2.1 核函数与核技巧
- 2.3 软间隔与正则化
- 2.4 支持向量回归
三、代码实战
- 3.1 数据准备
- 3.2 算法实现
- 3.3 运行结果及分析
四、总结

一、线性SVM

1.1 最大间隔与分类

在样本空间中寻找一个超平面, 将不同类别的样本分开，同时，这条线要与样本点有着尽可能大的间隔。那么，这条线就是在最边缘的两个样本点的中间，这些边缘的样本点就称为支持向量。

要找到最大间隔，就是求两点之间的距离。正负样本支持向量间的距离就等于两倍正样本到分类线的距离。

其中，分子=1
得到距离：

最终问题变成了求解
上述已知支持向量的点的绝对值为1，则在它们后面的就应该>=1
如下公式易证：若得到的分类正确，那么yi的值与其待入值同向。

转为求最小值

1.2 对偶问题

在约束条件下求最小值，使用拉格朗日乘数法

在SVM求解w最小值的情况下，得到以下步骤：

最后只剩下未知数αi

1.3 SMO算法流程

最后求解α

二、非线性SVM

2.1 核函数与核技巧

在线性不可分的情况下，选择一个核函数将其映射到高维空间使其线性可分

其中，ϕ是设样本x映射后的向量为ϕ(x), 得到划分超平面为f(x)=wTϕ(x)+b

这样求解问题就分成了两步：
首先使用一个非线性映射将数据变换到一个特征空间F；
然后在特征空间使用线性学习器分类。
常见的核函数如下：

如果有一种方法可以在特征空间中直接计算内积<ϕ(x_i),ϕ(x)>，就像在原始输入点的函数中一样，就有可能将两个步骤融合到一起建立一个分线性的学习器，这样直接计算的方法称为核函数方法。
将内积替换成核函数的方式被称为核技巧(kernel trick)。

2.3 软间隔与正则化

实际应用中，很难选择合适的核函数，使样本在特征空间中线性可
分; 此外，线性可分的结果也很难断定是否是由过拟合造成的。于是引入“软间隔”的概念, 允许SVM在一些样本上不满足约束。

在求解最大化间隔的同时, 让不满足约束的样本应尽可能少，最终转为求解

其中C>0为惩罚参数

然而损失函数有着一定的缺陷：非凸、非连续, 不易优化，因此用替代损失函数。

2.4 支持向量回归

支持向量回归允许模型输出和实际输出间存在2ε的偏差

其中，ε为松弛变量，反映了对野点的容忍程度

于是求解变成了：

三、代码实战

3.1 数据准备

选择随机生成的数据集，用make_hastie-10-2生成。有十个维度，标签是两种，因此做二分类。随机生成一千条数据，80%做训练，20%做测试

data, label = datasets.make_hastie_10_2(n_samples=1000)
x_train, x_test, y_train, y_test = train_test_split(data, label, test_size=0.2)

3.2 算法实现

数据结构

class optStruct:"""数据结构，维护所有需要操作的值Parameters：dataMatIn - 数据矩阵classLabels - 数据标签C - 松弛变量toler - 容错率kTup - 包含核函数信息的元组,第一个参数存放核函数类别，第二个参数存放必要的核函数需要用到的参数"""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)))  # 根据矩阵行数初始化alpha参数为0self.b = 0  # 初始化b参数为0self.eCache = np.mat(np.zeros((self.m, 2)))  # 根据矩阵行数初始化虎误差缓存，第一列为是否有效的标志位，第二列为实际的误差E的值。self.K = np.mat(np.zeros((self.m, self.m)))  # 初始化核Kfor i in range(self.m):  # 计算所有数据的核Kself.K[:, i] = kernelTrans(self.X, self.X[i, :], kTup)

计算核函数，通过核函数将数据转换更高维的空间

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, :] - AK[j] = deltaRow * deltaRow.TK = np.exp(K / (-1 * kTup[1] ** 2))  # 计算高斯核Kelse:raise NameError('核函数无法识别')return K  # 返回计算的核K

smo算法

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

优化的smo算法

def innerL(i, oS):# 步骤1：计算误差EiEi = 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,并计算Ejj, Ej = selectJ(i, oS, Ei)# 保存更新前的aplpha值，使用深拷贝alphaIold = oS.alphas[i].copy()alphaJold = oS.alphas[j].copy()# 步骤2：计算上下界L和Hif (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# 步骤3：计算etaeta = 2.0 * oS.K[i, j] - oS.K[i, i] - oS.K[j, j]if eta >= 0:print("eta>=0")return 0# 步骤4：更新alpha_joS.alphas[j] -= oS.labelMat[j] * (Ei - Ej) / eta# 步骤5：修剪alpha_joS.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# 步骤6：更新alpha_ioS.alphas[i] += oS.labelMat[j] * oS.labelMat[i] * (alphaJold - oS.alphas[j])# 更新Ei至误差缓存updateEk(oS, i)# 步骤7：更新b_1和b_2b1 = 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]# 步骤8：根据b_1和b_2更新bif (0 < oS.alphas[i]) and (oS.C > oS.alphas[i]):oS.b = b1elif (0 < oS.alphas[j]) and (oS.C > oS.alphas[j]):oS.b = b2else:oS.b = (b1 + b2) / 2.0return 1else:return 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

内循环启发方式计算Ej

def selectJ(i, oS, Ei):maxK = -1maxDeltaE = 0Ej = 0  # 初始化oS.eCache[i] = [1, Ei]  # 根据Ei更新误差缓存validEcacheList = np.nonzero(oS.eCache[:, 0].A)[0]  # 返回误差不为0的数据的索引值if (len(validEcacheList)) > 1:  # 有不为0的误差for k in validEcacheList:  # 遍历,找到最大的Ekif k == i: continue  # 不计算i,浪费时间Ek = calcEk(oS, k)  # 计算EkdeltaE = abs(Ei - Ek)  # 计算|Ei-Ek|if (deltaE > maxDeltaE):  # 找到maxDeltaEmaxK = kmaxDeltaE = deltaEEj = Ekreturn maxK, Ej  # 返回maxK,Ejelse:  # 没有不为0的误差j = selectJrand(i, oS.m)  # 随机选择alpha_j的索引值Ej = calcEk(oS, j)  # 计算Ejreturn j, Ej  # j,Ej

修剪alpha_j

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

更新Ej至误差缓存

def updateEk(oS, k):"""计算Ek,并更新误差缓存Parameters：oS - 数据结构k - 标号为k的数据的索引值Returns:无"""Ek = calcEk(oS, k)  # 计算EkoS.eCache[k] = [1, Ek]  # 更新误差缓存

可视化样本标签

def showDataSet(dataMat, labelMat):# 正样本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])# 转换为numpy矩阵data_plus_np = np.array(data_plus)# 转换为numpy矩阵data_minus_np = np.array(data_minus)# 正样本散点图（scatter）# transpose转置plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1])# 负样本散点图（scatter）plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1])# 显示plt.show()

3.3 运行结果及分析

样本分类可视化：

运行结果：

数据集采用随机生成的方式能很好的运行svm并且有较高的正确率

四、总结

SVM从原理到代码实现难度都挺大，现在还是没怎么吃透，以后还需加强它的学习。