机器学习——SVM

1. 概述

        1.1 SVM概念

                支持向量机（Support Vector Machine，SVM）是一种机器学习算法，用于分类和回归分析。它能够有效地处理线性可分和线性不可分的数据，并在高维空间中构建最优的决策边界。

                SVM的核心思想是找到一个超平面，将不同类别的样本点尽可能地分开，并且使得两个类别之间的间隔最大化。这个超平面称为最大间隔超平面，它可以很好地进行分类预测。

                具体而言，SVM通过将样本映射到高维特征空间，使得数据在该空间中线性可分。如果在原始输入空间中无法找到一个线性超平面将数据分开，SVM引入了核函数，将计算复杂度从高维特征空间转移到原始输入空间中。常用的核函数有线性核、多项式核和高斯核等。

                SVM的训练过程是一个凸优化问题，目标是最小化模型的结构风险。在求解过程中，SVM只关注那些位于决策边界附近的样本，它们被称为支持向量。这种特性使得SVM具有较好的鲁棒性和泛化能力。

                总体而言，SVM是一种强大的机器学习算法，能够处理高维空间的数据，并通过寻找最优超平面实现分类和回归分析。它在许多领域如图像识别、文本分类和生物信息学中都取得了广泛的应用。

        1.2 SVM理论知识

                        线性可分支持向量机

如图，当两类点被一条直线完全分开叫做线性可分。

严格的数学定义是：

D0 和 D1 是 n 维欧氏空间中的两个点集。如果存在 n 维向量 w 和实数 b，使得所有属于 D0 的点Xi都有 wXi+b>0 ，而对于所有属于 D1 的点 �� 则有 wXi+b<0 ，则我们称 D0 和 D1 线性可分。

由于情况不同，分割直线可能不止一条。

                最大间隔超平面

从二维扩展到多维空间中时，将 D0 和 D1 完全正确地划分开的 wx+b=0 就成了一个超平面。

为了使这个超平面更具鲁棒性，我们会去找最佳超平面，以最大间隔把两类样本分开的超平面，也称之为最大间隔超平面。

两类样本分别分割在该超平面的两侧；
两侧距离超平面最近的样本点到超平面的距离被最大化了。

                支持向量

样本中距离超平面最近的一些点，这些点叫做支持向量。

                对偶问题

        对偶问题是通过引入拉格朗日乘子，将原始的SVM优化问题转化为一个更简化的等价问题。通过求解对偶问题，我们可以得到原始问题的最优解，并且获得与SVM相关的其他重要信息。

        对偶问题的求解步骤如下：

                1：构建拉格朗日函数：将原始问题的目标函数和约束条件转化成拉格朗日函数。

                        

                2：对拉格朗日函数进行最大化：对拉格朗日函数进行求导，并令导数为0，求解得到最大化的拉格朗日函数。

                ​​​​​​​        

                3：求解原始问题的最优解：通过求解对偶问题得到的最大化拉格朗日函数，可以得到原始问题的最优解。

                        

                核函数

        核函数是用于将数据从原始特征空间映射到一个高维空间中的一种技术。它能够克服在低维特征空间中线性不可分的问题，从而实现对非线性问题的分类。核函数主要作用是计算样本之间的内积，以度量它们之间的相似性。在SVM的求解过程中，核函数被用于替代原始优化问题中的内积运算，从而将样本映射到一个高维的特征空间中进行处理。

        我们常用核函数有：

2. 代码求解线性SVM

        2.1 可视化数据集

                我们使用简单的数据集进行测试，局部数据如下图：

        ​​​​​​​        

              2.1.1 可视化数据集代码：

import matplotlib.pyplot as plt
import numpy as np
"""
函数说明:读取数据
Parameters:
    fileName：文件名
Returns:
    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
"""
函数说明：数据可视化
Parameters:
    dataMat：数据矩阵
    labelMat：数据标签
Returns:
    无
"""
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])
    data_plus_np = np.array(data_plus)             
    data_minus_np = np.array(data_minus)       
    #正样本散点图     
    plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1])   
    #负样本散点图
    plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1]) 
    plt.show()
if __name__ == '__main__':
    dataMat, labelMat = loadDataSet('testSet.txt')
    showDataSet(dataMat, labelMat)

                2.1.2 可视化结果：

       结果分析： 这就是我们使用的二维数据集，显然线性可分。可使用简化版的SMO算法进行求解。

        2.2  SMO算法求解 

                2.2.1 SMO算法代码

from time import sleep
import matplotlib.pyplot as plt
import numpy as np
import random
import types
"""
函数说明:读取数据
Parameters:
    fileName：文件名
Returns:
    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
"""
函数说明:随机选择alpha
Parameters:
    i：alpha
    m：alpha参数个数
Returns:
    j
"""
def selectJrand(i, m):
    j = i
    while (j == i):
        j = int(random.uniform(0, m))
    return j
"""
函数说明:修剪alpha
Parameters:
    aj：alpha值
    H：alpha上限
    L：alpha下限
Returns:
    aj：alpah值
"""
def clipAlpha(aj,H,L):
    if aj > H:
        aj = H
    if L > aj:
        aj = L
    return aj
"""
函数说明:简化版SMO算法
Parameters:
    dataMatIn：数据矩阵
    classLabels：数据标签
    C：松弛变量
    toler：容错率
    maxIter：最大迭代次数
Returns:
    无
"""
def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    #转换为numpy的mat存储
    dataMatrix = np.mat(dataMatIn); labelMat = np.mat(classLabels).transpose()
    #初始化b参数，统计dataMatrix的维度
    b = 0; m,n = np.shape(dataMatrix)
    #初始化alpha参数，设为0
    alphas = np.mat(np.zeros((m,1)))
    #初始化迭代次数
    iter_num = 0
    #最多迭代matIter次
    while (iter_num < maxIter):
        alphaPairsChanged = 0
        for i in range(m):
            #步骤1：计算误差Ei
            fXi = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b
            Ei = fXi - float(labelMat[i])
            #优化alpha，更设定一定的容错率。
            if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):
                #随机选择另一个与alpha_i成对优化的alpha_j
                j = selectJrand(i,m)
                #步骤1：计算误差Ej
                fXj = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[j,:].T)) + b
                Ej = fXj - float(labelMat[j])
                #保存更新前的aplpha值，使用深拷贝
                alphaIold = alphas[i].copy(); alphaJold = alphas[j].copy();
                #步骤2：计算上下界L和H
                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
                #步骤3：计算eta
                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
                #步骤4：更新alpha_j
                alphas[j] -= labelMat[j]*(Ei - Ej)/eta
                #步骤5：修剪alpha_j
                alphas[j] = clipAlpha(alphas[j],H,L)
                if (abs(alphas[j] - alphaJold) < 0.00001): print("alpha_j变化太小"); continue
                #步骤6：更新alpha_i
                alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
                #步骤7：更新b_1和b_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
                #步骤8：根据b_1和b_2更新b
                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("第%d次迭代 样本:%d, alpha优化次数:%d" % (iter_num,i,alphaPairsChanged))
        #更新迭代次数
        if (alphaPairsChanged == 0): iter_num += 1
        else: iter_num = 0
        print("迭代次数: %d" % iter_num)
    return b,alphas
"""
函数说明：分类结果可视化
Parameters:
    dataMat：数据矩阵
    w：直线法向量
    b：直线解决
Returns:
    无
"""
def showClassifer(dataMat, 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)
    data_minus_np = np.array(data_minus)
    #正样本散点图
    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
Parameters:
    dataMat：数据矩阵
    labelMat：数据标签
    alphas：alphas值
Returns:
    无
"""
def get_w(dataMat, labelMat, alphas):
    alphas, dataMat, labelMat = np.array(alphas), np.array(dataMat), np.array(labelMat)
    w = np.dot((np.tile(labelMat.reshape(1, -1).T, (1, 2)) * dataMat).T, alphas)
    return w.tolist()
if __name__ == '__main__':
    dataMat, labelMat = loadDataSet('testSet.txt')
    b,alphas = smoSimple(dataMat, labelMat, 0.6, 0.001, 40)
    w = get_w(dataMat, labelMat, alphas)
    showClassifer(dataMat, w, b)

 2.2.2 运行结果

        结果分析：中间的蓝线为求出来的分类器，用红圈圈出的点为支持向量点。 

3. 总结

        3.1 实验结果分析

                1.实验的训练错误率与测试错误率结果可以看出，由于数据本身就存在很强的线性关系，可以很容易找到我们所需要的向量将其分割开。

        2.我们一直假设训练样本在样本空间或特征空间中是线性可分的，即存在一个超平面能将不同类的样本完全划分开。然而在现实任务中往往很难确定合适的核函数使得训练样本在特征空间中线性可分，也很难断定这个貌似线性可分的结果不是由于过拟合造成的。缓解该问题的一个办法是允许支持向量机在一些样本上出错。为此，要引入“软间隔”的概念。

        3.2 SVM的优缺点

        优点:

                1：可用于线性/非线性分类，也可以用于回归，泛化错误率低，也就是说具有良好的学习能力，且学到的结果具有很好的推广性。
                2：可以解决小样本情况下的机器学习问题，可以解决高维问题，可以避免神经网络结构选择和局部极小点问题。
                3：SVM是最好的现成的分类器，现成是指不加修改可直接使用。并且能够得到较低的错误率，SVM可以对训练集之外的数据点做很好的分类决策。
        缺点：

                1：对参数调节和和函数的选择敏感。

                2：难以处理大规模数据集

                3：对缺失数据敏感