机器学习-支持向量机[入门]

最新推荐文章于 2023-12-27 18:04:39 发布

H驱逐舰H

最新推荐文章于 2023-12-27 18:04:39 发布

阅读量501

点赞数 1

分类专栏：机器学习文章标签：机器学习算法

本文链接：https://blog.csdn.net/weixin_45104240/article/details/107669414

版权

机器学习专栏收录该内容

7 篇文章 3 订阅

订阅专栏

一、概述

支持向量机(Support Vector Machines，SVM,也称为支持向量网络)，是机器学习中获得关注最多的算法没有之一。它源于统计学理论,是我们除了集成算法之外,接触的第一个强学习器。它有多强呢?从算法的功能来看，SVM几乎囊括了我之前的几篇博客的所有算法的功能，从分类效力来讲，SVM在无论线性还是分线性分类中，都是明星般的存在。
在这里插入图片描述

我通过一个故事来进行讲解什么是SVM。

在很久以前，大侠的心上人被反派囚禁,大侠想要去救出他的心上人，于是便去和反派谈判。反派说只要你能顺利通过三关，我就放了你的心上人。
现在大侠的闯关正式开始:
第一关:反派在桌子上似乎有规律地放了两种颜色的球，说:你用一根棍子分离开他们，要求是尽量再放更多的球之后，仍然适用。
在这里插入图片描述
大侠很干净利索的放了一根棍子如下：

第二关：反爬在桌子放上了更多的求，似乎有一个红球站错了阵营。

SVM就是试图把棍放在最佳位置，好让在棍的两边有尽可能大的间隙。

于是大侠将棍子调整如下，现在即使反派放入更多的球，棍子仍然是一个很好的分界线。
在这里插入图片描述

其实在SVM工具箱里还有另一个更加重要的trick。反派看到大侠已经学会了一个trick,于是心生-计,给大侠更
难的一个挑战。
第三关:反派将球散乱地放在桌子上。
在这里插入图片描述
现在大侠已经没有方法用一根棍子将这些球分开了，怎么办呢?大侠灵机一动,使出三成内力拍向桌子，然后桌子上的球就被震到空中，说时迟那时快，大侠瞬间抓起一张纸，插到了两种球的中间。

现在从反派的角度看这些球，这些球像是被一条曲线分开了。于是反派乖地放了大侠的心上人。
在这里插入图片描述
从此之后，江湖人便给这些分别起了名字,把这些球叫做data，把棍子叫做classifier , 最大间隙trick叫做optimization，拍桌子叫做 kernelling ,那张纸叫做hyperplane。

       我在网上找到一个视频，非常的直观的展示了上述过程，在这里分享给大家。
在这里插入图片描述
概述一下：
       当一个分类问题，数据是线性可分(linearly separable)的，也就是用一根棍就可以将两种小球分开的时候,我们只要将棍的位置放在让小球距离棍的距离最大化的位置即可，寻找这个最大间隔的过程，就叫做最优化。但是，现实往往是很残酷的，一般的数据是线性不可分的，也就是找不到一个棍将两种小球很好的分类。这个时候，我们就需要像大侠一样,将小球拍起，用一张纸代替小棍将小球进行分类。想要让数据飞起,我们需要的东西就是核函数(kernel)，于切分小球的纸，就是超平面(hyperplane) 。如果数据集是N维的，那么超平面就是N-1维的。
在这里插入图片描述
       把一个数据集正确分开的超平面可能有多个（如下图），而那个具有”最大间隔的超平面就是SVM要寻找的最优解。而这个真正的最优解对应的两侧虚线所穿过的样本点，就是SVM中的支持样本点,称为支持向量(support vector)"。支持向量到超平面的距离被称为间隔(margin)。
在这里插入图片描述

二、线性SVM（线性可分SVM）

       求解这个"超平面"的过程，就是最优化。一个最优化问题通常有两个最基本的因素:
       (1)目标函数，也就是你希望什么东西的什么指标达到最好;
       (2)优化对象，你期望通过改变哪些因素来使你的目标函数达到最优。
       在线性SVM算法中，目标函数显然就是那个“间隔”，而优化对象则是超平面。我们以线性可分的二分类问题为例

1.超平面方程

       在线性可分的二分类问题中，超平面其实就是一条直线。相信直线方程大家都不陌生:
              y=ax+b (公式1)
现在我们做个小小的改变，让原来的x轴变成x₁轴，y变成x₂轴，于是公式(1)中的直线方程变成下面的样子:
              x₂ = ax₁ +b (公式2)
              ax₁+(-1)x₂+b = 0 (公式3)
向量形式可以写成：
在这里插入图片描述
进一步可表示为：
              ω^Tx+b = 0 (公式5)
看到变量ω，x略显粗壮的身体了吗?他们是黑体，表示变量是个向量， ω= [ω₁,ω₂]^T，x=[x₁,x₂]^T。一般我们提到向量的时候，都默认是列向量，所以对ω进行了转置。这里向量w与直线是相互垂直的，也就是说ω控制了直线的方向，b就是截距，它控制了直线的位置。

2.间隔的计算公式

“间隔”其实就是点到直线的距离。这里采用向量法:
d= $\frac{|ω^Tx+b|}{||ω||}$ (公式6)
这里||ω||是向量ω的模，假如ω= [w₁,w₂]^T，则|ω||= √ω²₁+ω²₂ ,表示在空间中向量的长度, x= [x1,x2]就支持向量样本点的坐标。ω，b就是超平面方程的参数。
我们的目标是找出一个分类效果好的超平面作为分类器。分类器的好坏评定依据是分类间隔的W = 2d的大小，即分类间隔W越大，我们认为这个超平面的分类效果越好。而追求分类间隔W的最大化也就是寻找d的最大化。

3.约束条件

       虽然我们找到了目标函数，但是:(1)我们如何判断一条直线能够将所有的样本点都正确分类?(2)超平面的位置应该是在间隔区域的中轴线上，所以确定超平面位置的b参数也不能随意的取值。(3)对于一个给定的超平面，我们如何找到对应的支持向量，来计算距离d?
       上述三个问题就是"约束条件”，也就是说，我们要优化的变量的取值范围收到了约束和限制。既然约束确实存在，那么就不得不用数学语言对它们进行描述。这里需要说明的是SVM可以通过一些小技巧，将这些约束条件糅合成一个不等式。请看下面糅合过程:
       以下图为例，在平面空间中有红蓝两种点，分别标记为:
       红色为正样本，标记为+1;
       蓝色为负样本，标记为-1. 在这里插入图片描述
       对每个样本点x;加上类别标签y，则有

       如果我们的超平面能够完全将红蓝两种样本点分离开，那么则有

三、SMO算法

1.什么是SMO算法

SMO算法就是序列最小优化(Sequential Minimal Optimization)，它是由John Platt 于1996年发布的专用于训练SVM的一个强大算法，和梯度下降法一样专门用于逻辑回归算法的算法类似。SMO算法的目的是将大优化问题分解为多个小优化问题来求解。这些小优化问题往往很容易求解，粗对它们进行顺序成解的结果与将它们作为整体来求解的结果完全一致的。在结果完全相同的同时，SMO算法的求解时间短很多。
SMO算法的目标是计算出权重向量ω并得到分隔超平面。

2.简化版SMO算法

SMO算法的完整版实现需要大量的代码。这里我们先讨论SMO算法的简化版,主要用来正确理解这个算法的工作流程。然后会对这个简化版的SMO算法进行优化，加快它的运行速度。

SMO的伪代码

创建一个向量并初始化为0向量
当迭代次数 < 最大迭代次数时(外循环):
	对数据集中每个数据向量(内循环):
		如果该数据向量可以被优化:
			随机选择另外一个数据向量
			同时优化这两个向量
			如果两个向量都不能被优化，则退出内循环
	如果所有向量都没被优化，迭代次数+1，继续下一次循环

四、编程求解线性SVM

看完SMO算法实现步骤，接下来按照下面思路编写代码，进行实战练习。

1.导入可视化数据集、

我们先使用简单的数据集进行测试，数据集下载地址：
链接：https://pan.baidu.com/s/1S_i0usVi0T7MWrS1jVVhyg
提取码：bv9r
编写程序可视化数据集，看下它长什么样子：

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)              #转换为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()

if __name__ == '__main__':
    dataMat, labelMat = loadDataSet('testSet_svm.txt')
    showDataSet(dataMat, labelMat)

运行程序，查看结果：
在这里插入图片描述
这就是我们使用的二维数据集，显然线性可分。现在我们使用简化版的SMO算法进行求解。

2.简化版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                                 #选择一个不等于i的j
    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)              #转换为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()

"""
函数说明:计算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_svm.txt')
    b,alphas = smoSimple(dataMat, labelMat, 0.6, 0.001, 40)
    w = get_w(dataMat, labelMat, alphas)
    showClassifer(dataMat, w, b)

程序运行结果：
在这里插入图片描述
其中，中间的蓝线为求出来的分类器，用红圈圈出的点为支持向量点。

PS：由于本系列文章为入门文章，写的目的在于为初学机器学习的萌新更容易理解基本原理所写，所以本篇文章省略掉了很多数据公式和生涩难懂的东西。感兴趣学习更深层次的小伙本可以看看网上的其他内容，我也会抽时间专门写几篇更深入的文章。

不会真的没人点赞关注吧
在这里插入图片描述

H驱逐舰H

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
机器学习-支持向量机[入门]

一、概述支持向量机(Support Vector Machines，SVM,也称为支持向量网络)，是机器学习中获得关注最多的算法没有之一。它源于统计学习理论,是我们除了集成算法之外,接触的第一个强学习器。它有多强呢?从算法的功能来看，SVM几乎囊括了我之前的几篇博客的所有算法的功能:功能有监督学习线性二分类与多分类非线性二分类与多分类(Support Vector Classification, SVC)普通连续型变量的回归(Support Vector Regression)
复制链接

扫一扫

专栏目录