通过间隔最大化→分离超平面:wTx+b=0→决策函数:h(x)=sign(wTx+b)
函数间隔与几何间隔:
间隔最大化:
因为函数间隔的取值不影响问题求解
使等号成立的样本成为“支持向量”
优化问题求解:
SVM的一个重要性质:训练完成后,大部分样本不需要保留,最终模型仅与支持向量有关。
核函数
将样本从原始空间映射到高维特征空间,使其线性可分
如果原始空间是有限的,即特征维数有限,那么一定存在一个高维特征空间是样本可分
任何一个核函数都隐式地定义了一个称为“再生核希尔伯特空间RKHS”的特征空间
核函数的选择应用:
- 当特征维数小,样本数适中大时,选用RBF高斯核;
- 当特征维数远大于样本数时,选用线性核;
- 当特征维数和样本数都很大时,选用线性核;
- 当特征维数远行小于样本数时,选用RBF高斯核,或者增加特征使用线性核或LR;
软间隔与正则化
“软间隔”:允许某些样本不满足约束: yi(w⋅xi+b)≥1
在最大化间隔时,不满足约束的样本应尽可能少,优化目标为:
当C无穷大时,硬间隔所有样本均要满足约束;当C为有限值时,软间隔允许某些样本不满足约束
软间隔支持向量机的最终模型仅与支持向量有关,即采用hinge损失仍保持了稀疏性
如果使用log对率损失函数,几乎就得到了逻辑(对率)回归模型。实际上LR和SVM的优化目标想接近,性能也相当。LR的优势在于其输出具有概率意义,即在给出预测标记的同时也给出了概率。
hinge损失函数使得SVM的解具有稀疏性,而对率损失是光滑的递减函数,不能导出类似支持向量的概念,因此对率回归的解依赖于更多的训练样本,预测开销更大。
不同损失函数的SVM优化目标:
SMO(Sequence Minimal Optimization)序列最小化:
固定一对需要更新的变量,固定其他变量,优化它们,重复上述步骤直至收敛。
约束的二维空间图形表示:
变量的选择方法
第一个变量的选择(外层循环):在训练样本中选择违背KKT条件最严重的样本点,并将其对应的变量作为第1个变量。检验过程中,首先遍历所有支持向量点,检验它们是否满足KKT条件。如果这些样本点均满足KKT条件,遍历整个训练集,检验它们是否满足KKT条件。
第二个变量的选择(内层循环):选择足够大变化的变量,即使|E1-E2|最大。(特殊情况下,上述方法选择的变量不能使目标函数有足够的下降,那么采用启发式规则选择:遍历支持向量点,依次将其对应的变量选为第二个变量,直到目标函数有足够的下降。若找不到,那么遍历整个训练集;若仍找不到,则退到外层循坏重新找第一个变量。)
计算阈值b和插值E
#SMO主要代码
def selectJrand(i,m):
j=i #we want to select any J not equal to i
while (j==i):
j = int(random.uniform(0,m))
return j
def clipAlpha(aj,H,L):
if aj > H:
aj = H
if L > aj:
aj = L
return aj
#计算核函数值
def kernelTrans(X, A, kTup): #kTup参数,kTup[0]是使用何种核函数,之后是核函数参数
m,n = shape(X)
K = mat(zeros((m,1)))
if kTup[0]=='lin': K = X * A.T #linear kernel
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))
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
self.tol = toler #容错率
self.m = shape(dataMatIn)[0]
self.alphas = mat(zeros((self.m, 1)))
self.b = 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)
#计算更新后的Ek
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
#内循环,选择第二个变量,使得Ei-Ej最大
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):
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]
#更新alpha,E,b
def innerL(i, oS):
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: print("L==H"); return 0
eta = oS.K[i,i] + oS.K[j,j] - 2.0 * oS.K[i,j]
if eta >= 0: 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): print("j not moving enough"); return 0
oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])#更新第一个变量
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
updateEk(oS, i)
return 1
else: return 0
#SMO主函数
def smoP(dataMatIn, classLabels, C, toler, maxIter,kTup=('lin', 0)):
oS = optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,toler)
iter = 0
entireSet = True; alphaPairsChanged = 0
while (iter < maxIter) and ((alphaPairsChanged > 0) or (entireSet)):
alphaPairsChanged = 0
#选择第一个alpha
'''理论应该先遍历边界值,不行再遍历整个数据集,但alph初始为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))
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
#计算W
def calcWs(alphas,dataArr,classLabels):
X = mat(dataArr); labelMat = mat(classLabels).transpose()
m,n = shape(X)
w = zeros((n,1))
for i in range(m):
w += multiply(alphas[i]*labelMat[i],X[i,:].T)
return w
支持向量回归SVR
优缺点:
分析:支持向量机依靠边界样本来建立需要的分离曲线。它可以处理非线性决策边界。对边界的依赖,也使得它们有能力处理缺失数据中“明显的”样本实例。支持向量机能够处理大的特征空间,也因此成为文本分析中最受欢迎的算法之一,由于文本数据几乎总是产生大量的特征,所以在这种情况下逻辑回归并不是一个非常好的选择。SVM的结果并不像决策树那样直观。同时使用非线性核,使得支持向量机在大型数据上的训练非常耗时。
优点:
1.能够处理大型特征空间
2.能够处理非线性特征之间的相互作用
3.无需依赖整个数据
缺点:
1.当观测样本很多时,效率并不是很高
2.有时候很难找到一个合适的核函数
LR 与 SVM:
- 如果Feature的数量很大,跟样本数量差不多,这时候选用LR或者是Linear Kernel的SVM
- 如果Feature的数量比较小,样本数量一般,不算大也不算小,选用SVM+Gaussian Kernel
- 如果Feature的数量比较小,而样本数量很多,需要手工添加一些feature变成第一种情况