机器学习方法---SVM

代码实现

简单版本

创建一个alpha向量并将其初始化为0向量
当迭代次数小于最大迭代次数时（外循环）
\qquad 对数据集中的每个数据向量（内循环）：
\qquad 如果该数据向量可以被优化：
\qquad \qquad 随机选择另外一个数据向量
\qquad \qquad 同时优化这两个向量
\qquad \qquad 如果两个向量都不能被优化，退出内循环
如果所有向量都没被优化，增加迭代数目，继续下一次循环

from numpy import *
from time import sleep

"""
func: 加载数据

param: 
    fileName: 文件名

return:
    dataMat: 数据矩阵
    labelMat：标签矩阵
"""
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
    
"""
func: 在给定范围内随机选择一个整数

param: 
    i: 第一个alpha的下标，不能等于该整数
    m: 所有alpha的数目，即指定的范围

return:
    j: 选择的整数
"""
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

"""
func: 当数值太大或太小时对其进行调整

param: 
    aj: 需调整的值
    H：设定的最高值
    L：设定的最低值

return:
    aj：调整好的值
"""
def clipAlpha(aj,H,L):
    if aj > H: 
        aj = H
    if L > aj:
        aj = L
    return aj

"""
func: 简化版SMO算法

param: 
    dataMatIn: 数据集
    classLabels: 类别标签
    C: 常数C
    toler: 容错率
    maxIter: 最大的循环次数

return:
    b: 阈值 (wTx + b)y
    alpha: 优化的参数值
"""
def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    dataMatrix = mat(dataMatIn); labelMat = mat(classLabels).transpose()
    # m: 数据集的数量，n: 特征数量
    b = 0; m,n = shape(dataMatrix)
    alphas = mat(zeros((m,1)))
    # 没有任何alpha改变的情况下遍历数据集的次数，当该变量达到输入值maxIter时，函数结束运行并退出。
    iter = 0
    while (iter < maxIter):
        # 记录alpha是否已进行优化
        alphaPairsChanged = 0
        for i in range(m):
            fXi = float(multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b
            Ei = fXi - float(labelMat[i])#if checks if an example violates KKT conditions
            # 如果alpha可以更改进入优化过程，在if语句中，不管是正间隔还是负间隔都会被测试。
            #并且在该if语句中，也要同时检查alpha值，以保证其不能等于0或C。由于后面alpha小于0或大于
            #C时将被调整为0或C，所以一旦在该if语句中它们等于这两个值的话，那么它们就已经在“边界”
            #上了，因而不再能够减小或增大，因此也就不值得再对它们进行优化了。
            if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):
                # 随机选择第二个alpha
                j = selectJrand(i,m)
                fXj = float(multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[j,:].T)) + b
                Ej = fXj - float(labelMat[j])
                alphaIold = alphas[i].copy(); alphaJold = alphas[j].copy()
                
                # 保证alpha在0和C之间
                if (labelMat[i] != labelMat[j]):
                    L = max(0, alphas[j] - alphas[i])
                    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
                # 简化处理
                if eta >= 0: print("eta>=0"); continue
                alphas[j] -= labelMat[j]*(Ei - Ej)/eta
                alphas[j] = clipAlpha(alphas[j],H,L)
                if (abs(alphas[j] - alphaJold) < 0.00001): print "j not moving enough"; continue
                alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])#update i by the same amount as j
                                                                        #the update is in the oppostie direction
                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