人工智能-机器学习-支持向量机

亦凉 2022-10-19 15:49 311阅读 0赞

# 一.概述 #

**支持向量机即SVM(Support Vector Machine)，主要用于解决模式识别领域中的数据分类问题，属于有监督学习算法的一种。是一类按监督学习方式对数据进行二元分类的广义线性分类器。**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center]  
**如图所示, 红色和蓝色的点是可以被一条直线分开的, 在模式识别领域称为线性可分问题, 然而将两类数据点分开的直线显然不止一条, b图和c图分别给出了A, B两种不同的分类方案, 其中黑色实线为分类线, 术语称为"决策面"。每个决策面对应了一个线性分类器。  
虽然在目前的数据上看, 这两个分类器的分类结果是一样的, 但如果考虑潜在的其他数据, 则两者的分类性能是有差别的。这点, 我们在以下章节讨论。**

# 二.SVM损失函数 #

## 1.合页损失函数 ##

**假设一个二分类问题, 标签d分别为-1和1, 构建线性模型为 y= wx + b, 损失函数为:**  
 l o s s = max ⁡ ( 1 − y ⋅ d , 0 ) loss= \\max(1-y \\cdot d,0) loss=max(1−y⋅d,0)  
**该损失函数为合页损失函数(Hinge loss), 如果距离分类边界较远, 则将损失函数置为0, 如果距离较近, 则损失函数为 1- yd, 相当于只考虑难分的数据点, 而忽略易分的样本点带来的损失, 因为难分的样本点如果都分清了的话, 那么容易分的自然而然的就分清了, 这些难分的数据点称为"支持向量", 我们可以利用较少的样本点(支持向量)完成分类。**

**我们绘制一下合页损失函数:**

""" 合页损失函数 loss = max(1 - yd, 0), 因为 d 的取值为 -1 和 1, 则按此绘图 """
    import numpy as np
    import matplotlib.pyplot as plt
    
    plt.switch_backend("TkAgg")
    
    
    def model(y, d):
        return [max([1 - i * d, 0]) for i in y]
    
    
    # 准备 -5 到 5 均匀排列的 1000 个点
    y = np.linspace(-2, 2, 1000).tolist()
    
    L_1 = model(y[0:500], -1)
    L_2 = model(y[500:], 1)
    
    L = np.concatenate((L_1, L_2), axis=0)
    
    # get current axis 获得坐标轴对象
    ax = plt.gca()
    
    # 将右边 边沿线颜色设置为空 其实就相当于抹掉这条边
    ax.spines['right'].set_color('none')
    ax.spines['top'].set_color('none')
    ax.xaxis.set_ticks_position('bottom')
    ax.yaxis.set_ticks_position('left')
    
    # 设置中心的为（0，0）的坐标轴
    # 指定 data 设置的bottom(也就是指定的x轴)绑定到y轴的0这个点上
    ax.spines['bottom'].set_position(('data', 0))
    ax.spines['left'].set_position(('data', 0))
    
    # x轴数值设置
    plt.xlim(-2, 2)
    plt.ylim(-2, 2)
    
    # 绘制曲线图
    plt.plot(y, L, c="r", lw=2)
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 1]  
**其中横轴为y的取值, 纵轴为损失值, 汇出的图像像个开关门用的合页(铰链), 因此叫合页损失函数。**

## 2. 支持向量机的损失函数 ##

**支持向量机的损失函数为: 合页损失 + 正则损失**  
 L = max ⁡ ( 1 − y i ⋅ d i , 0 ) + 1 2 ∣ w ∣ 2 L= \\max(1-y\_i \\cdot d\_i,0) + \\frac\{1\}\{2\}\\lvert w \\rvert^2 L=max(1−yi⋅di,0)\+21∣w∣2  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 2]  
**如图所示, 设定有两类点, 特征分别是横纵轴 x1, x2, 标签d分别是 -1 和 1, 构建预测线性模型为 y = wx + b, 图中设分类边界为 y = 0, 离分类边界最近的点分别是 y = 1 和 y = -1, 所以离分类边界最远的点的 y 值都是 y > 1 或者 y < -1,所以在两类点的所在范围中, y 与 d 的乘积肯定是大于等于 1 的,我们假设所有的样本都满足这个条件(s.t.: 使…满足…的意思):**

s . t . d i ⋅ y i ≥ 1 ∀ i s.t. \\quad d\_i\\cdot y\_i \\geq 1 \\quad \\forall i s.t.di⋅yi≥1∀i

**同时我们希望在正则损失比较小的情况下(因为就是让损失函数比较小)满足上述这个条件:**

s . t . L = 1 2 ∣ w ∣ 2 s.t. \\quad L = \\frac\{1\}\{2\}\\lvert w \\rvert^2 s.t.L=21∣w∣2

**从几何的角度来看, 由点到直线的距离公式为:**

L = ∣ A x 0 + B y 0 + C A 2 + B 2 ∣ L = \\begin\{vmatrix\} \\frac\{Ax\_0 + By\_0 + C\}\{\\sqrt\{A^2 + B^2\}\} \\end\{vmatrix\} L=∣∣∣A2\+B2Ax0\+By0\+C∣∣∣

**设有一个点 s, s的预测值 y = 1, 到直线 y = 0(即直线 wx + b = 0)的距离, 代入即为:**  
 d = ∣ w x 0 + b ∣ w 2 d = \\frac\{\\lvert wx\_0 + b \\rvert\}\{ \\sqrt\{w ^2\}\} d=w2∣wx0\+b∣

**由于 s 点 y 值为 1, 即 wx0 + b = 1, 所以:**  
 d = 1 w 2 d = \\frac\{1\}\{ \\sqrt\{w ^2\}\} d=w21

所 以 当 d = 1 w 2 越 来 越 大 的 时 候 , 正 则 函 数 L = 1 2 ∣ w ∣ 2 才 会 越 来 越 来 小 所以当\\quad d = \\frac\{1\}\{ \\sqrt\{w ^2\}\} \\quad 越来越大的时候, 正则函数 \\quad L = \\frac\{1\}\{2\}\\lvert w \\rvert^2 \\quad 才会越来越来小 所以当d=w21越来越大的时候,正则函数L=21∣w∣2才会越来越来小

**所以在概述中所描绘的两种划分形式, b 是要好于 c 的。**

**所以 SVM 在划分边界时要遵循:**

在 所 有 的 点 均 满 足 d i ⋅ y i ≥ 1 时 , L = 1 2 ∣ w ∣ 2 ( 目 标 函 数 ) 要 尽 可 能 的 小 在所有的点均满足 \\quad d\_i\\cdot y\_i \\geq 1 \\quad 时, \\quad L = \\frac\{1\}\{2\}\\lvert w \\rvert^2 (目标函数)\\quad要尽可能的小 在所有的点均满足di⋅yi≥1时,L=21∣w∣2(目标函数)要尽可能的小  
**此种问题为约束最优化问题, 可以采用拉格朗日乘子解决该问题:**  
 J = 1 2 w 2 − α i ( ( w ⋅ x i + b ) d i − 1 ) ( α i 为 拉 格 朗 日 乘 子 ) J = \\frac\{1\}\{2\} w^2 - \\alpha\_i((w \\cdot x\_i +b)d\_i -1)\\quad (\\alpha\_i 为拉格朗日乘子) J=21w2−αi((w⋅xi\+b)di−1)(αi为拉格朗日乘子)  
**当取得极值时, 需要同时满足以下条件:**  
 ∂ J ∂ w = 0 , ∂ J ∂ b = 0 , ∂ J ∂ α = 0 \\frac \{\\partial J\}\{\\partial w\} = 0, \\frac \{\\partial J\}\{\\partial b\} = 0, \\frac \{\\partial J\}\{\\partial \\alpha\} = 0 ∂w∂J=0,∂b∂J=0,∂α∂J=0

且 需 满 足 α ≥ 0 ; 当 ( w ⋅ x i + b ) d i − 1 = 0 时 , α > 0 ; 当 ( w ⋅ x i + b ) d i − 1 > 0 时 , α = 0 此 类 条 件 为 K K T 条 件 且需满足\\quad \\alpha \\geq 0; \\quad 当\\quad (w \\cdot x\_i +b)d\_i -1 =0 \\quad 时,\\alpha > 0 ; \\quad 当 \\quad (w \\cdot x\_i +b)d\_i -1 >0 \\quad 时,\\alpha = 0 此类条件为KKT条件 且需满足α≥0;当(w⋅xi\+b)di−1=0时,α>0;当(w⋅xi\+b)di−1>0时,α=0此类条件为KKT条件

即 当 α > 0 时 , ( w ⋅ x i + b ) d i = 1 , 即 为 难 分 的 数 据 点 , 当 α = 0 时 , ( w ⋅ x i + b ) d i > 1 , 即 为 易 分 的 数 据 点 即当 \\alpha > 0 时, \\quad (w \\cdot x\_i +b)d\_i = 1, 即为难分的数据点,当 \\alpha = 0 时, \\quad (w \\cdot x\_i +b)d\_i > 1, 即为易分的数据点 即当α>0时,(w⋅xi\+b)di=1,即为难分的数据点,当α=0时,(w⋅xi\+b)di>1,即为易分的数据点  
**所以拉格朗日函数从另一个角度看, 就是 合页损失函数 + 正则损失函数。**

**接下来我们求解下以上的偏导公式:**  
 由 ∂ J ∂ w = 0 , 可 推 导 出 w = α i d i x i 由 \\frac \{\\partial J\}\{\\partial w\} = 0,可推导出\\quad w=\\alpha\_i d\_i x\_i 由∂w∂J=0,可推导出w=αidixi  
 由 ∂ J ∂ b = 0 , 可 推 导 出 α i d i = 0 由 \\frac \{\\partial J\}\{\\partial b\} = 0,可推导出\\quad \\alpha\_i d\_i = 0 由∂b∂J=0,可推导出αidi=0

**代回上述拉格朗日 J 原式:**  
 J = α i + α i b d i + 1 2 w 2 − α i w x i d i , 其 中 α i b d i = 0 J = \\alpha\_i + \\alpha\_ibd\_i + \\frac\{1\}\{2\} w^2 - \\alpha\_iwx\_id\_i, 其中 \\alpha\_ibd\_i = 0 J=αi\+αibdi\+21w2−αiwxidi,其中αibdi=0

1 2 w 2 − α i w x i d i = − 1 2 a i d i x i a j d j x j \\frac\{1\}\{2\} w^2 - \\alpha\_iwx\_id\_i =-\\frac\{1\}\{2\} a\_i d\_i x\_i a\_j d\_j x\_j 21w2−αiwxidi=−21aidixiajdjxj

**分别求和后的最终形式为:**  
 Q ( α ) = ∑ i N α i − 1 2 ∑ i N ∑ j N α i α j d i d j ( x i ⋅ x j ) ) Q(\\alpha)=\\sum\_i^N \\alpha\_i - \\frac 1 2 \\sum\_i^N \\sum\_j^N \\alpha\_i \\alpha\_j d\_i d\_j (x\_i \\cdot x\_j)) Q(α)=i∑Nαi−21i∑Nj∑Nαiαjdidj(xi⋅xj))  
**以上称为拉格朗日对偶形式(求J的极小值相当于求Q得极大值), 并且我们只需针对 α 进行求解, 当 α 不为 0 的部分, 即为支持向量。**

**此前我们建立的线性可转换为模型为：**  
 y = ∑ i N α i d i ( x i ⋅ x ) + b y= \\sum\_i^N \\alpha\_i d\_i (x\_i \\cdot x) +b y=i∑Nαidi(xi⋅x)\+b  
**此时w可以由支持向量来表示了。**

## 3. 松弛因子 ##

**加入松弛边界 ξ后:**

在 满 足 s . t . ( x i ⋅ w + b ) d i ≥ 1 − ξ i ; ξ i ≥ 0 时 在满足\\quad s.t.(x\_i \\cdot w+b)d\_i \\geq 1- \\xi\_i; \\xi\_i\\geq0 \\quad时 在满足s.t.(xi⋅w\+b)di≥1−ξi;ξi≥0时  
 损 失 函 数 为 : L = 1 2 w 2 + C ξ 损失函数为: \\quad L = \\frac\{1\}\{2\}w^2 + C\\xi 损失函数为:L=21w2\+Cξ

拉 格 朗 日 乘 子 的 范 围 由 0 ≤ α i ≤ + ∞ 变 为 0 ≤ α i ≤ C 拉格朗日乘子的范围由 \\quad0 \\leq \\alpha\_i \\leq +\\infty \\quad变为\\quad 0 \\leq \\alpha\_i \\leq C 拉格朗日乘子的范围由0≤αi≤\+∞变为0≤αi≤C  
**C越小, 参与的支持向量越多**

# 三.支持向量机 #

## 1.线性分类 ##

""" SVM算法时间复杂度取决于支持向量个数，虽然结果上与 单层神经网络(逻辑回归)类似，但是实现原理并不相同 """
    
    from sklearn.svm import SVC
    from sklearn.datasets import make_classification
    import matplotlib.pyplot as plt
    import numpy as np
    
    plt.switch_backend("TkAgg")
    
    # 一.准备数据
    
    # 利用sklearn提供的 make_classification 创造随机数据
    
    # n_samples: 默认100个样本, n_features: 特征为 2个, n_informative: 有信息特征数量为2,
    # n_redundant: 冗余特征数量为0, n_clusters_per_class: 每一类的簇数为 1,
    # class_sep: 不同类别样本的分散程度为1, random_state: 为 1, 每次生产的随机数不变
    train_x, train_y = make_classification(n_features=2, n_informative=2, n_redundant=0,
                                           random_state=1, n_clusters_per_class=1, class_sep=1)
    
    # 二.构建模型
    
    # 定义SVM分类器类, 分类核心为 线性核心
    svm_model = SVC(kernel='linear')
    # 进行训练
    svm_model.fit(train_x, train_y)
    
    
    # 三. 绘制网格
    
    # 定义网格，用于绘制等值线图
    # 算出最大值和最小值, 并分别扩大 0.5 的距离
    x_1_min, x_1_max = train_x[:, 0].min() - .5, train_x[:, 0].max() + .5
    x_2_min, x_2_max = train_x[:, 1].min() - .5, train_x[:, 1].max() + .5
    
    # 方法: X, Y = np.meshgrid(x, y), x, y为网格点的横纵坐标列向量, X，Y为坐标矩阵
    # 横纵坐标为从 x_1_min, x_1_max; x_2_min, x_2_max步长为 0.1
    z1, z2 = np.meshgrid(np.arange(x_1_min, x_1_max, 0.1), np.arange(x_2_min, x_2_max, 0.1))
    
    
    # ravel() 方法为将矩阵拉平为一维矩阵
    # np.c_ 为两个矩阵左右相加(行不变, 列合并, 要求是两个矩阵的行数要相等),
    # 如果是一维数组, 则自动转为二维数组, 原始的一维数组作为二维数组的列
    # np.c_[z1.ravel(), z2.ravel()] 则为得到一个个组成网格的点
    
    # 输出样本距离各个分类器的分隔超平面的置信度，并由此可以推算出predict的预测结果
    Z = svm_model.decision_function(np.c_[z1.ravel(), z2.ravel()])
    # 整合为网格的形状大小
    Z = Z.reshape(z1.shape)
    
    # 绘制等高线并以Z为标准填充颜色
    plt.contourf(z1, z2, Z, alpha=.8)
    
    # 绘制散点图, 颜色为标签 train_y, 表框为黑色
    plt.scatter(train_x[:, 0], train_x[:, 1], c=train_y, edgecolors='k')
    
    # 绘制支持向量
    sv = svm_model.support_vectors_
    plt.scatter(sv[:, 0], sv[:, 1], s=60, marker='^', color="#000099")
    
    # 解决中文显示问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    plt.title("支持向量机")
    
    # x,y轴等长
    plt.axis("equal")
    
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 3]

**在方法 svm\_model = SVC(kernel=‘linear’) 中, 可以加入参数 C, 调整支持向量的个数, C 取值越小，支持向量个数越多，越不容易受到噪声的影响。**

svm_model = SVC(kernel='linear', C=0.1)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 4]

## 2.非线性分类 ##

**对于线性分类无法解决的数据, 我们可以通过 kernel tirck 将数据映射到非线性空间。以rbf核心和poly核心的支持向量机比较常用，可以用于非线性分类问题。**

### 2.1 径向基核函数 rbf ###

k e r n e l = e − ∣ x s − x ∣ 2 γ kernel = e^\{- \\frac\{\\lvert x\_s -x \\lvert^2\}\{\\gamma\}\} kernel=e−γ∣xs−x∣2

**参数 γ 可以理解为支持向量影响区域半径的倒数, γ越大, 支持向量影响区域越小，决策边界更容易只包含支持向量, 模型复杂度高，容易过拟合; γ越小，支持向量影响区域越大, 模型复杂度低，容易欠拟合**

""" SVM 分线性划分 """
    
    from sklearn.svm import SVC
    from sklearn.datasets import make_moons
    import matplotlib.pyplot as plt
    import numpy as np
    
    plt.switch_backend("TkAgg")
    
    # 一.准备数据
    
    # 利用sklearn提供的 make_classification 创造随机数据
    
    # n_samples: 默认100个样本, noise: 设置高斯噪音的标准差为 0.3
    # random_state: 为 0, 每次生产的随机数不变
    train_x, train_y = make_moons(noise=0.3, random_state=0)
    
    
    # 二.构建模型
    
    # 定义SVM分类器类, 选用rbf为核心, 随着gamma增大，细节越丰富，
    # 但是容易出现过拟合问题
    svm_model = SVC(kernel='rbf', gamma=2.0, C=1.0)
    
    # 进行训练
    svm_model.fit(train_x, train_y)
    
    
    # 三. 绘制网格
    
    # 定义网格，用于绘制等值线图
    # 算出最大值和最小值, 并分别扩大 0.5 的距离
    x_1_min, x_1_max = train_x[:, 0].min() - .5, train_x[:, 0].max() + .5
    x_2_min, x_2_max = train_x[:, 1].min() - .5, train_x[:, 1].max() + .5
    
    # 方法: X, Y = np.meshgrid(x, y), x, y为网格点的横纵坐标列向量, X，Y为坐标矩阵
    # 横纵坐标为从 x_1_min, x_1_max; x_2_min, x_2_max步长为 0.1
    z1, z2 = np.meshgrid(np.arange(x_1_min, x_1_max, 0.1), np.arange(x_2_min, x_2_max, 0.1))
    
    
    # ravel() 方法为将矩阵拉平为一维矩阵
    # np.c_ 为两个矩阵左右相加(行不变, 列合并, 要求是两个矩阵的行数要相等),
    # 如果是一维数组, 则自动转为二维数组, 原始的一维数组作为二维数组的列
    # np.c_[z1.ravel(), z2.ravel()] 则为得到一个个组成网格的点
    
    # 输出样本距离各个分类器的分隔超平面的置信度，并由此可以推算出predict的预测结果
    Z = svm_model.decision_function(np.c_[z1.ravel(), z2.ravel()])
    # 整合为网格的形状大小
    Z = Z.reshape(z1.shape)
    
    # 绘制等高线并以Z为标准填充颜色
    plt.contourf(z1, z2, Z, alpha=.8)
    
    # 绘制散点图, 颜色为标签 train_y, 表框为黑色
    plt.scatter(train_x[:, 0], train_x[:, 1], c=train_y, edgecolors='k')
    
    # 绘制支持向量
    sv = svm_model.support_vectors_
    plt.scatter(sv[:, 0], sv[:, 1], s=40, marker='^', color="#000099")
    
    # 解决中文显示问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    plt.title("支持向量机")
    
    # x,y轴等长
    plt.axis("equal")
    
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 5]

### 2.2 多项式核函数 poly ###

**将特征进行多项式升维处理, 幂次越大模型越容易过拟合**

""" SVM 分线性划分 """
    
    from sklearn.svm import SVC
    from sklearn.datasets import make_moons
    import matplotlib.pyplot as plt
    import numpy as np
    
    plt.switch_backend("TkAgg")
    
    # 一.准备数据
    
    # 利用sklearn提供的 make_classification 创造随机数据
    
    # n_samples: 默认100个样本, noise: 设置高斯噪音的标准差为 0.3
    # random_state: 为 0, 每次生产的随机数不变
    train_x, train_y = make_moons(noise=0.3, random_state=0)
    
    
    # 二.构建模型
    
    # 定义SVM分类器类, 选用poly为核心, degree表示多项式的次数
    svm_model = SVC(kernel='poly', degree=3)
    
    # 进行训练
    svm_model.fit(train_x, train_y)
    
    
    # 三. 绘制网格
    
    # 定义网格，用于绘制等值线图
    # 算出最大值和最小值, 并分别扩大 0.5 的距离
    x_1_min, x_1_max = train_x[:, 0].min() - .5, train_x[:, 0].max() + .5
    x_2_min, x_2_max = train_x[:, 1].min() - .5, train_x[:, 1].max() + .5
    
    # 方法: X, Y = np.meshgrid(x, y), x, y为网格点的横纵坐标列向量, X，Y为坐标矩阵
    # 横纵坐标为从 x_1_min, x_1_max; x_2_min, x_2_max步长为 0.1
    z1, z2 = np.meshgrid(np.arange(x_1_min, x_1_max, 0.1), np.arange(x_2_min, x_2_max, 0.1))
    
    
    # ravel() 方法为将矩阵拉平为一维矩阵
    # np.c_ 为两个矩阵左右相加(行不变, 列合并, 要求是两个矩阵的行数要相等),
    # 如果是一维数组, 则自动转为二维数组, 原始的一维数组作为二维数组的列
    # np.c_[z1.ravel(), z2.ravel()] 则为得到一个个组成网格的点
    
    # 输出样本距离各个分类器的分隔超平面的置信度，并由此可以推算出predict的预测结果
    Z = svm_model.decision_function(np.c_[z1.ravel(), z2.ravel()])
    # 整合为网格的形状大小
    Z = Z.reshape(z1.shape)
    
    # 绘制等高线并以Z为标准填充颜色
    plt.contourf(z1, z2, Z, alpha=.8)
    
    # 绘制散点图, 颜色为标签 train_y, 表框为黑色
    plt.scatter(train_x[:, 0], train_x[:, 1], c=train_y, edgecolors='k')
    
    # 绘制支持向量
    sv = svm_model.support_vectors_
    plt.scatter(sv[:, 0], sv[:, 1], s=40, marker='^', color="#000099")
    
    # 解决中文显示问题
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    
    plt.title("支持向量机")
    
    # x,y轴等长
    plt.axis("equal")
    
    plt.show()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 6]

## 总结: ##

**支持向量机优势:  
1.对样本数量需求较少。  
2.支持向量机在处理样本数量较少，非均衡样本的时候有一定优势。**

**支持向量劣势:  
1.容易受到噪声的影响，在向量较长的时候计算速度偏慢。  
2.支持向量机难以处理样本特征比较多的情况。可能需要配合降维方法使用。**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221004/14e6470543b04235b1e8a0b21ab9bb84.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221004/0036bfd06f714d019251a745ad3c12a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221004/6213d530fa394076898410940b66ffc7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221004/e01789ac7bce4417b69d9fe211ecac36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221004/7b43b53df92a4e39b6371b359bf38529.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221004/d4e487a212234980b30fd2ecee06a6d8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h5eTEwMjg_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221004/4bee9fbe88ca44819aee31acb0fc8452.png