机器学习————SVM

最新推荐文章于 2024-06-11 10:43:51 发布

顽强的代码人

最新推荐文章于 2024-06-11 10:43:51 发布

阅读量637

点赞数 28

文章标签：支持向量机机器学习算法

本文链接：https://blog.csdn.net/m0_73044708/article/details/139304547

版权

一、SVM

1.1 概述

支持向量机（Support Vector Machine，简称SVM）是一种经典的机器学习算法，它在解决小样本、非线性及高维模式识别等问题中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中。
是一种二分类模型，监督性学习。目的是找到集合边缘上的若干数据（支持向量）用这些点找出一个平面（决策面）使支持向量到该平面的距离最大。

1.2 四种分隔的情况

此外，我们将详细介绍一些线性可分的情况

如上图所示，在图A中的两组数据已经分的足够开，因此很容易就可以画一条直线将两组数据点分开。
这种情况下，这组数据就被称为线性可分数据。

将数据集分开的直线称为分割超平面。当数据点都在二维平面上时，分割超平面只是一条直线。当数据集是三维时就是一个平面。如果数据集是N维的，那么就需要N-1维的某某对象对数据进行分割。该对象就被称为超平面也是分类的决策边界。

根据这种方法我们构造一个分类器，如果数据点离决策边界越远，那么其最后的预测结果也就越可信

点到分割线的距离称为间隔
而支持向量就是离分隔超平面最近的那些点。

1.3 最大间隔与分类

什么样的决策边界才是最好的呢？
首先我们引入
超平面方程：

$w^Tx+b=0$

对于线性可分的数据集来说，超平面有许多个，但几何间隔最大的分离超平面是唯一的。
① 两类样本分别分割在超平面的两侧
② 两侧距离超平面最近的样本点到超平面的距离被最大化

点

$x=(x_1,x_2,\ldots\ldots x_n)$

到直线

$w^Tx+b=0$

距离为

$\frac{(w^Tx+b)}{||w||}$

其中

$||w||=\sqrt{w_1^2+\ldots\ldots+w_n^2}$

$\begin{cases}&\frac{(w^Tx+b)}{||w||}\geq d,y=1\\&\frac{(w^Tx+b)}{||w||}\leq-d,y=-1\end{cases}$

支持向量（正、负）之差为

$\frac2{||w||}$

则最大间隔转化为求其最大值

$arg\max_{w,b}\frac2{||w||}$

即

$arg\min_{w,b}\frac12||w||^2$

1.4 对偶问题：等式约束

引入拉格朗日函数：

$L(x,\lambda)=f(x)+\lambda g(x)$

可将原本约束条件转换为

$\min_{x,\lambda}L(x,\lambda)$

分别求偏导得

$\begin{cases}&\nabla_xL=\nabla f+\lambda\nabla g=0\\&\nabla_\lambda L=g(X)=0\end{cases}$

转换为KKT条件

$\begin{cases}&\nabla_xL=\nabla f+\lambda\nabla g=0\\&g(x)\leq0\\&\lambda\geq0\\&\lambda g(x)=0\end{cases}$

通过SMO优化求得最优解

1.5 核函数

将样本从原始空间映射到一个更高维的特征空间, 使得样本在这个特
征空间内线性可分

例如

$ax_1^2+bx_2^2+cx_1x_2=1$

转化为

$w_1z_1+w_2z_2+w_3z_3+b=0$

二、实现

2.1 数据集介绍

数据集格式为（x,y,label）

2.2 代码

2.2.1 数据可视化部分

loadDataSet函数：读取文件中的数据，将其加载到数据矩阵和标签矩阵中。

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

showDataSetha函数：将数据集以散点图的形式显示出来，区分正样本和负样本。

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)              #转换为numpy矩阵
    data_minus_np = np.array(data_minus)            #转换为numpy矩阵
    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()

2.2.2 SMO实现

selectJrand函数：随机选择alpha，随机选择一个不等于 i 的整数 j，范围是 [0, m)。

def selectJrand(i, m):
    j = i                                 #选择一个不等于i的j
    while (j == i):
        j = int(random.uniform(0, m))
    return j

clipAlpha函数：修剪alpha，使其保持在 [L, H] 之间

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

smoSimple函数：实现简化版的SMO算法，用于训练线性SVM

步骤：

初始化参数 b 和 alpha。
在最大迭代次数范围内，不断优化 alpha。
每次从样本中选择 i 和 j 两个不同的样本，计算它们的误差 Ei 和 Ej。
计算 alpha 的新的值并进行修剪，确保在合法范围内。
更新 b 值。
重复上述过程直到满足停止条件。

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

showClassifer函数：绘制数据点和分类超平面，同时标记出支持向量

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)              #转换为numpy矩阵
    data_minus_np = np.array(data_minus)            #转换为numpy矩阵
    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()

get_w函数：根据 alpha 值和样本计算SVM的权重向量，用于定义分类超平面

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()

2.2.3 结果

数据集可视化

SMO算法结果：

三、总结

优点

计算复杂性取决于向量数目而不是样本空间维数
可以处理线性不可分
可实现特征空间划分的最优超平面
简化了回归和分类等问题
抓住了关键样本，具有较好鲁棒性，增删非支持向量样本对模型没有影响

缺点

大规模训练难实施
多分类问题解决困难

顽强的代码人

关注

28
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
机器学习————SVM

支持向量机（Support Vector Machine，简称SVM）是一种经典的机器学习算法，它在解决小样本、非线性及高维模式识别等问题中表现出许多特有的优势，并能够推广应用到函数拟合等其他机器学习问题中。是一种二分类模型，监督性学习。目的是找到集合边缘上的若干数据（支持向量）用这些点找出一个平面（决策面）使支持向量到该平面的距离最大。数据集格式为（x,y,label）优点计算复杂性取决于向量数目而不是样本空间维数可以处理线性不可分可实现特征空间划分的最优超平面简化了回归和分类等问题。
复制链接

扫一扫