机器学习第三周-支持向量机

支持向量机

支持向量机是最好的现成分类器，所谓现成是指分类器不加任何的修改就可以直接的使用，同时，这就意味着在数据上用最基本的SVM 分类器就可以得到低错误率的结果，SVM能对训练集之外的数据点做出很好的分类决策。

本章主要学习最小序列化的算法。

基本概念

线性可分数据：在图中可以很容易使用一条直线将两组数据点分开，该直线成为分隔超平面

间隔： 我们希望能通过上述的方式来构建分类器，即如果数据点离决策边界越远，那么其最后的预测结果也就越可信。既然这样，我们希望找到离分隔超平面最近的点，确保它们离分隔面的距离尽可能远。这里所说的点到分隔面的距离就是 间隔。我们希望间隔尽可能地大，这是因为如果我们犯错或者在有限数据上训练分类器的话，我们希望分类器尽可能健壮。

支持向量：离分隔超平面最近的那些点

分类器：分类器就是给定一个样本的数据，判定这个样本属于哪个类别的算法。

特征：在分类问题中，输入到分类器中的数据叫做特征。

如何寻找最大间隔

分隔超平面的形式可以写成其中常数b类似于逻辑回归中的截距

要计算一点到分隔超平面的距离，就必须给出点到分隔面的法线或者垂线的长度。该值为

使用分类器求解最优化问题

输入数据会给分类器会输出一个类别标签，这个类似于sigmoid函数。但和逻辑回归不同，那里的类标签是0和1，但是这里的类标签是-1和1。这主要是方便我们后续在数学中运算的方便。当计算数据点到分隔面的距离并确定了防止的位置，间隔通过label*（w^t+b）来计算，这时就能体现出+1，-1的好处了。如果数据点在正方向，离分隔平面很远，那么根据上面的式子，结果会是一个很大的正数，相反，如果处于负方向，并且离超平面很远时，依然还是得到一个很大的正数。

想在的目标就是找出分类器定义中的w和b，为此我们必须找到具有最小间隔的数据点（支持向量），找到这些最小间隔以后，我们就需要对该间隔最大化。但实际求解这个目标式是比较困难的。我们进一步转换。令所有支持向量的label*（w^{t+b）【点到分隔面的函数间隔】都为1，那么就可以通过求解||w||}（-1）的最大值来得到最终解。这样，只有离平面最近大的几个点的值才为1，其他的都大于这个值，在上面的优化问题中，我们给定了一些约束条件求优化值，问题是一个带约束条件的优化问题。约束条件是label*（w^t+b）>=1；求解这样的优化问题，我们可以采用拉格朗日乘子法。

注释：label*（w^t+b）*||w||(-1) 称为分隔面的几何间隔。

SVM的一般流程

(1) 收集数据：可以使用任意方法。
(2) 准备数据：需要数值型数据。  
(3) 分析数据：有助于可视化分隔超平面。  
(4) 训练算法：SVM的大部分时间都源自训练，该过程主要实现两个参数的调优。 
(5) 测试算法：十分简单的计算过程就可以实现。 
(6) 使用算法：几乎所有分类问题都可以使用SVM，值得一提的是，SVM本身是一个二类 分类器，对多类问题应用SVM需要对代码做一些修改。  

SMO 高效优化算法

SMO算法的目标式求出一系列的alpha和b，一旦求出了这些alpha，就很容易计算出权重向量w并且得到分隔平面

SMO的原理是：每次循环中选择两个alpha进行优化处理，一旦找到一对合适的alpha，那么久增大其中一个同时减小另一个。这里所谓的合适

SVM 伪代码

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

案例–对小规模数据分类

准备数据

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

训练算法

–转载aphachecn的备注程序

def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    """smoSimple
    """
    dataMatrix = mat(dataMatIn)
    # 矩阵转置 和 .T 一样的功能
    labelMat = mat(classLabels).transpose()
    m, n = shape(dataMatrix)

    # 初始化 b和alphas(alpha有点类似权重值。)
    b = 0
    alphas = mat(zeros((m, 1)))

    # 没有任何alpha改变的情况下遍历数据的次数
    iter = 0
    while (iter < maxIter):
        # w = calcWs(alphas, dataMatIn, classLabels)
        # print("w:", w)

        # 记录alpha是否已经进行优化，每次循环时设为0，然后再对整个集合顺序遍历
        alphaPairsChanged = 0
        for i in range(m):
            # print 'alphas=', alphas
            # print 'labelMat=', labelMat
            # print 'multiply(alphas, labelMat)=', multiply(alphas, labelMat)
            # 我们预测的类别 y[i] = w^Tx[i]+b; 其中因为 w = Σ(1~n) a[n]*label[n]*x[n]
            fXi = float(multiply(alphas, labelMat).T*(dataMatrix*dataMatrix[i, :].T)) + b
            # 预测结果与真实结果比对，计算误差Ei
            Ei = fXi - float(labelMat[i])

            # 约束条件 (KKT条件是解决最优化问题的时用到的一种方法。我们这里提到的最优化问题通常是指对于给定的某一函数，求其在指定作用域上的全局最小值)
            # 0<=alphas[i]<=C，但由于0和C是边界值，我们无法进行优化，因为需要增加一个alphas和降低一个alphas。
            # 表示发生错误的概率：labelMat[i]*Ei 如果超出了 toler， 才需要优化。至于正负号，我们考虑绝对值就对了。
            '''
            # 检验训练样本(xi, yi)是否满足KKT条件
            yi*f(i) >= 1 and alpha = 0 (outside the boundary)
            yi*f(i) == 1 and 0<alpha< C (on the boundary)
            yi*f(i) <= 1 and alpha = C (between the boundary)
            '''
            if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):

                # 如果满足优化的条件，我们就随机选取非i的一个点，进行优化比较
                j = selectJrand(i, m)
                # 预测j的结果
                fXj = float(multiply(alphas, labelMat).T*(dataMatrix*dataMatrix[j, :].T)) + b
                Ej = fXj - float(labelMat[j])
                alphaIold = alphas[i].copy()
                alphaJold = alphas[j].copy()

                # L和H用于将alphas[j]调整到0-C之间。如果L==H，就不做任何改变，直接执行continue语句
                # labelMat[i] != labelMat[j] 表示异侧，就相减，否则是同侧，就相加。
                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]值
                alphas[j] -= labelMat[j]*(Ei - Ej)/eta
                # 并使用辅助函数，以及L和H对其进行调整
                alphas[j] = clipAlpha(alphas[j], H, L)
                # 检查alpha[j]是否只是轻微的改变，如果是的话，就退出for循环。
                if (abs(alphas[j] - alphaJold) < 0.00001):
                    print("j not moving enough")
                    continue
                # 然后alphas[i]和alphas[j]同样进行改变，虽然改变的大小一样，但是改变的方向正好相反
                alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
                # 在对alpha[i], alpha[j] 进行优化之后，给这两个alpha值设置一个常数b。
                # w= Σ[1~n] ai*yi*xi => b = yj- Σ[1~n] ai*yi(xi*xj)
                # 所以：  b1 - b = (y1-y) - Σ[1~n] yi*(a1-a)*(xi*x1)
                # 为什么减2遍？ 因为是 减去Σ[1~n]，正好2个变量i和j，所以减2遍
                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 (0 < alphas[i]) and (C > alphas[i]):
                    b = b1
                elif (0 < alphas[j]) and (C > alphas[j]):
                    b = b2
                else:
                    b = (b1 + b2)/2.0
                alphaPairsChanged += 1
                print("iter: %d i:%d, pairs changed %d" % (iter, i, alphaPairsChanged))
        # 在for循环外，检查alpha值是否做了更新，如果更新则将iter设为0后继续运行程序
        # 直到更新完毕后，iter次循环无变化，才退出循环。
        if (alphaPairsChanged == 0):
            iter += 1
        else:
            iter = 0
        print("iteration number: %d" % iter)
    return b, alphas

核函数

核函数的作用：使用核函数，可以将数据从某个特征空间到另外一个特征空间，一般是将n为拓展到n+1为，这样就可以用分隔超平面进行分隔了

考完考试把核函数例子自己实现以下。。。