菜菜的scikit-learn课堂——sklearn中的支持向量机SVM（下）

1 二分类SVC

1.1 SVC用于二分类的原理

支持向量机分类器，是在数据空间中找出一个超平面作为决策边界，利用这个决策边界来对数据进行分类，并使分类误差尽量小的模型。

决策边界是比所在数据空间小一维的空间，在三维数据空间中就是一个平面，在二维数据空间中就是一条直线。

平行于决策边界的两条虚线是距离决策边界相对距离为1的超平面，分别压过两类样本中距离决策边界最近的样本点，这些样本点就被成为支持向量。两条虚线超平面之间的距离叫做边际，简写为 $d$。

支持向量机分类器，就是以找出最大化的边际 $d$ 为目标来求解损失函数，以求解出参数 $\omega$ 和 $b$ ，以构建决策边界，然后用决策边界来分类的分类器。

但不是所有数据都是线性可分的，比如下面的环形数据。对于这样的数据，需要对它进行一个升维变化，来数据从原始的空间 $x$ 投射到新空间 $\varPhi \left( x \right)$ 中。升维之后，可以找出一个平面，能够将数据切分开来。 $\varPhi$ 是一个映射函数，它代表了某种能够将数据升维的非线性的变换，我们对数据进行这样的变换，确保数据在自己的空间中一定能够线性可分。

1.2 软间隔和硬间隔—参数C

有一些数据，可能是线性可分，但在线性可分状况下训练准确率不能达到100%，即无法让训练误差为0，这样的数据被称为“存在软间隔的数据”。

此时，需要让决策边界能够忍受一小部分训练误差，这个时候决策边界就不是单纯地寻求最大边际了，因为对于软间隔地数据来说，边际越大被分错的样本也就会越多，因此我们需要找出一个”最大边际“与”被分错的样本数量“之间的平衡。

因此，引入松弛系数 $\zeta$ 和松弛系数的系数C作为一个惩罚项，来惩罚我们对最大边际的追求。

参数C用于权衡”训练样本的正确分类“与”决策函数的边际最大化“两个不可同时完成的目标，希望找出一个平衡点来让模型的效果最佳。

那参数C如何影响我们的决策边界呢？

在硬间隔的时候，决策边界完全由两个支持向量和最小化损失函数（最大化边际）来决定，而支持向量是两个标签类别不一致的点，即分别是正样本和负样本。然而在软
间隔情况下边际依然由支持向量决定，但此时的支持向量可能就不再是来自两种标签类别的点了，而是分布在决策边界两边的同类别的点。

---

硬间隔

---

软间隔

在上图中，虚线超平面 $\boldsymbol{\omega }\cdot \boldsymbol{x}_{\boldsymbol{i}}+b=1-\zeta _i$ 是由混杂在红色点中间的紫色点来决定的，所以，这个紫色点就是我们的支持向量了。

所以软间隔让决定两条虚线超平面的支持向量可能是来自于同一个类别的样本点，而硬间隔的时候两条虚线超平面必须是由来自两个不同类别的支持向量决定的。

而 $C$ 值会决定我们究竟是依赖红色点作为支持向量（只追求最大边界），还是我们要依赖软间隔中，混杂在红色点中的紫色点来作为支持向量（追求最大边界和判断正确的平衡）。

• 如果 $C$ 值设定比较大，那SVC可能会选择边际较小的，能够更好地分类所有训练点的决策边界，不过模型的训练时间也会更长。
• 如果 $C$ 的设定值较小，那SVC会尽量最大化边界，尽量将掉落在决策边界另一方的样本点预测正确，决策功能会更简单，但代价是训练的准确度，因为此时会有更多红色的点被分类错误。

换句话说， $C$ 在SVM中的影响就像正则化参数对逻辑回归的影响。此时，所有可能影响我们的超平面的样本可能都会被定义为支持向量，所以支持向量就不再是所有压在虚线超平面上的点，而是所有可能影响我们的超平面的位置的那些混杂在彼此的类别中的点了。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import svm
from sklearn.datasets import make_circles, make_moons, make_blobs,make_classificationn_samples = 100# 构造四种数据
datasets = [make_moons(n_samples=n_samples, noise=0.2, random_state=0),make_circles(n_samples=n_samples, noise=0.2, factor=0.5, random_state=1),make_blobs(n_samples=n_samples, centers=2, random_state=5),make_classification(n_samples=n_samples,n_features = 2,n_informative=2,n_redundant=0, random_state=5)
]Kernel = ["linear"]#四个数据集分别是什么样子呢？
for X,Y in datasets:plt.figure(figsize=(5,4))plt.scatter(X[:,0],X[:,1],c=Y,s=50,cmap="rainbow")nrows=len(datasets)
ncols=len(Kernel) + 1fig, axes = plt.subplots(nrows, ncols,figsize=(10,16))#第一层循环：在不同的数据集中循环
for ds_cnt, (X,Y) in enumerate(datasets):#在图像中的第一列，放置原数据的分布ax = axes[ds_cnt, 0]if ds_cnt == 0:ax.set_title("Input data")ax.scatter(X[:, 0], X[:, 1], c=Y, zorder=10, cmap=plt.cm.Paired,edgecolors='k')ax.set_xticks(())ax.set_yticks(())#第二层循环：在不同的核函数中循环#从图像的第二列开始，一个个填充分类结果for est_idx, kernel in enumerate(Kernel):#定义子图位置ax = axes[ds_cnt, est_idx + 1]#建模clf = svm.SVC(kernel=kernel, gamma=2).fit(X, Y)score = clf.score(X, Y)#绘制图像本身分布的散点图ax.scatter(X[:, 0], X[:, 1], c=Y,zorder=10,cmap=plt.cm.Paired,edgecolors='k')#绘制支持向量ax.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1], s=100,facecolors='none', zorder=10, edgecolors='white')#绘制决策边界x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5#np.mgrid，合并了我们之前使用的np.linspace和np.meshgrid的用法#一次性使用最大值和最小值来生成网格#表示为[起始值：结束值：步长]#如果步长是复数，则其整数部分就是起始值和结束值之间创建的点的数量，并且结束值被包含在内XX, YY = np.mgrid[x_min:x_max:200j, y_min:y_max:200j]#np.c_，类似于np.vstack的功能Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()]).reshape(XX.shape)#填充等高线不同区域的颜色ax.pcolormesh(XX, YY, Z > 0, cmap=plt.cm.Paired)#绘制等高线ax.contour(XX, YY, Z, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],levels=[-1, 0, 1])#设定坐标轴为不显示ax.set_xticks(())ax.set_yticks(())#将标题放在第一行的顶上if ds_cnt == 0:ax.set_title(kernel)#为每张图添加分类的分数   ax.text(0.95, 0.06, ('%.2f' % score).lstrip('0'), size=15, bbox=dict(boxstyle='round', alpha=0.8, facecolor='white')#为分数添加一个白色的格子作为底色, transform=ax.transAxes #确定文字所对应的坐标轴，就是ax子图的坐标轴本身, horizontalalignment='right' #位于坐标轴的什么方向)plt.tight_layout()
plt.show()

四种数据集

核函数为线性核函数 Kernel = [“linear”]

白色圈圈出的就是支持向量，所有在两条虚线超平面之间的点，以及虚线超平面外但属于另一个类别的点，都被我们认为是支持向量。

并不是因为这些点都在超平面上，而是因为超平面由所有的这些点来决定，我们可以通过调节C来移动超平面，让超平面过任何一个白色圈圈出的点。参数C就是这样影响了我们的决策，可以说是彻底改变了支持向量机的决策过程。

1.3 二分类SVC中的样本不均衡问题：重要参数class_weight

分类学习方法都有一个共同的基本假设，即不同类别的训练样例数目相当。但若样本类别数目差别很大，属于极端不均衡，则会对学习过程（模型训练）造成困扰。

对于分类问题，样本不均衡是一个常见的问题。样本不均衡是指在一组数据集中，标签的一类天生占有很大的比例，但我们有着捕捉出某种特定的分类的需求的状况。

样本类别不均衡将导致样本量少的分类所包含的特征过少，并很难从中提取规律；即使得到分类模型，也容易产生过度依赖与有限的数据样本而导致过拟合问题，当模型应用到新的数据上时，模型的准确性会很差。

首先，分类模型天生会倾向于多数的类，让多数类更容易被判断正确，少数类被牺牲掉。因为对于模型而言，样本量越大的标签可以学习的信息越多，算法就会更加依赖于从多数类中学到的信息来进行判断。

如果我们希望捕获少数类，模型就会失败。其次，模型评估指标会失去意义。这种分类状况下，即便模型什么也不做，全部判断为多数类，准确率也能非常高，这使得模型评估指标 accuracy 变得毫无意义，根本无法达到分类的建模目的。

---

所以现在，我们首先要让算法意识到数据的标签是不均衡的，通过施加一些惩罚或者改变样本本身，来让模型向着捕获少数类的方向建模。然后，我们要改进我们的模型评估指标，使用更加针对于少数类的指标来优化模型。

要解决第一个问题，我们在逻辑回归中已经介绍了一些基本方法，比如上采样下采样。但这些采样方法会增加样本的总数，对于支持向量机这个样本总是对计算速度影响巨大的算法来说，我们完全不想轻易地增加样本数量。

况且，支持向量机中地决策仅仅决策边界的影响，而决策边界又仅仅受到参数C和支持向量的影响，单纯地增加样本数量不仅会增加计算时间，可能还会增加无数对决策边界无影响的样本点。

因此在支持向量机中，我们要大力依赖我们调节样本均衡的参数：SVC类中的class_weight 和接口 fit 中可以设定的 sample_weight。

在逻辑回归中，参数class_weight默认None，此模式表示假设数据集中的所有标签是均衡的，即自动认为标签的比例是1：1。

所以当样本不均衡的时候，我们可以使用形如{“标签的值1”：权重1，“标签的值2”：权重2}的字典来输入真实的样本标签比例，来让算法意识到样本是不平衡的。或者使用”balanced“模式，直接使用 n_samples/(n_classes * np.bincount(y)) 作为权重，可以比较好地修正我们的样本不均衡情况。

但在SVM中，我们的分类判断是基于决策边界的，而最终决定究竟使用怎样的支持向量和决策边界的参数是参数C，所以所有的样本均衡都是通过参数C来调整的。

SVC的参数：class_weight
可输入字典或者"balanced”，可不填，默认None 对SVC，将类 i 的参数C设置为class_weight [i] * C。 如果没有给出具体的 class_weight，则所有类都被假设为占有相同的权重1，模型会根据数据原本的状况去训练。如果希望改善样本不均衡状况，请输入形如{“标签的值1”：权重1，“标签的值2”：权重2}的字典，则参数C将会自动被设为： 标签的值1的C：权重1 * C，标签的值2的C：权重2*C 或者，可以使用“balanced”模式，这个模式使用y的值自动调整与输入数据中的类频率成反比的权重为n_samples/(n_classes * np.bincount(y))

SVC的接口 fit 的参数：sample_weight
数组，结构为 (n_samples, )，必须对应输入 fit 中的特征矩阵的每个样本 每个样本在fit时的权重，让权重 * 每个样本对应的C值来迫使分类器强调设定的权重更大的样本。通常，较大的权重加在少数类的样本上，以迫使模型向着少数类的方向建模 通常来说，这两个参数我们只选取一个来设置。如果我们同时设置了两个参数，则C会同时受到两个参数的影响，即 class_weight中设定的权重 * sample_weight中设定的权重 * C。

构造一组样本不平衡的数据集。在这组数据集上建两个SVC模型，一个设置有lass_weight参数，一个不设置class_weight参数。对两个模型分别进行评估并画出他们的决策边界，以此来观察class_weight带来的效果。

# 导入需要的库和模块
import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm
# 建立一堆一堆的数据集
from sklearn.datasets import make_blobs# 创建样本不均衡的数据集class_1 = 500 #类别1有500个样本
class_2 = 50 #类别2只有50个
centers = [[0.0, 0.0], [2.0, 2.0]] #设定两个类别的中心
clusters_std = [1.5, 0.5] #设定两个类别的方差，通常来说，样本量比较大的类别会更加松散
X, y = make_blobs(n_samples=[class_1, class_2],centers=centers,cluster_std=clusters_std,random_state=0, shuffle=False)
#看看数据集长什么样
plt.scatter(X[:, 0], X[:, 1], c=y, cmap="rainbow",s=10)

其中红色点是少数类，紫色点是多数类

在数据集上分别建模

#不设定class_weight
clf = svm.SVC(kernel='linear', C=1.0)
clf.fit(X, y)#设定class_weight
wclf = svm.SVC(kernel='linear', class_weight={1: 10})
wclf.fit(X, y)#给两个模型分别打分看看，这个分数是accuracy准确度
# 没有做样本均衡的准确率更高
clf.score(X,y)  # 0.9418181818181818
wclf.score(X,y)  # 0.9127272727272727

绘制两个模型下数据的决策边界

利用Contour函数来绘制决策边界。Contour是专门用来绘制等高线的函数。等高线，本质上是在二维图像上表现三维图像的一种形式，其中两维X和Y是两条坐标轴上的取值，而Z表示高度。

Contour就是将由X和Y构成平面上的所有点中，高度一致的点连接成线段的函数，在同一条等高线上的点一定具有相同的Z值。

决策边界是 $\boldsymbol{\omega }\cdot \boldsymbol{x}+b=0$ ，并在决策边界的两边找出两个超平面，使得超平面到决策边界的相对距离为1。那其实，只需要在我们的样本构成的平面上，把所有到决策边界的距离为0的点相连，就是决策边界。而到决策边界的距离可以使用接口decision_function来调用。

#首先要有数据分布
plt.figure(figsize=(6,5))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap="rainbow",s=10)
ax = plt.gca() #获取当前的子图，如果不存在，则创建新的子图
#绘制决策边界的第一步：要有网格
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx = np.linspace(xlim[0], xlim[1], 30)
yy = np.linspace(ylim[0], ylim[1], 30)
YY, XX = np.meshgrid(yy, xx)
xy = np.vstack([XX.ravel(), YY.ravel()]).T
#第二步：找出我们的样本点到决策边界的距离
Z_clf = clf.decision_function(xy).reshape(XX.shape)
a = ax.contour(XX, YY, Z_clf, colors='black', levels=[0], alpha=0.5, linestyles=['-'])
Z_wclf = wclf.decision_function(xy).reshape(XX.shape)
b = ax.contour(XX, YY, Z_wclf, colors='red', levels=[0], alpha=0.5, linestyles=['-'])
#第三步：画图例
plt.legend([a.collections[0], b.collections[0]], ["non weighted", "weighted"],loc="upper right")
plt.show()

a.collections #调用这个等高线对象中画的所有线，返回一个惰性对象
#用[*]把它打开试试看
[*a.collections] #返回了一个linecollection对象，其实就是我们等高线里所有的线的列表
#现在我们只有一条线，所以我们可以使用索引0来锁定这个对象
a.collections[0]
#plt.legend([对象列表],[图例列表],loc)
#只要对象列表和图例列表相对应，就可以显示出图例

从图像上可以看出，

• 灰色是我们做样本平衡之前的决策边界。灰色线上方的点被分为一类，下方的点被分为另一类。可以看到，大约有一半少数类（红色）被分错，多数类（紫色点）几乎都被分类正确了。

• 红色是我们做样本平衡之后的决策边界，同样是红色线上方一类，红色线下方一类。可以看到，做了样本平衡后，少数类几乎全部都被分类正确了，但是多数类有许多被分错了。

来看看两种情况下模型的准确率如何表现：

#给两个模型分别打分看看，这个分数是accuracy准确度
#做样本均衡之后，我们的准确率下降了，没有样本均衡的准确率更高
clf.score(X,y) # 0.9418181818181818
wclf.score(X,y) #  0.9127272727272727

可以看出，从准确率的角度来看，不做样本平衡的时候准确率反而更高，做了样本平衡准确率反而变低了，这是因为做了样本平衡后，为了要更有效地捕捉出少数类，模型误伤了许多多数类样本，而多数类被分错的样本数量 > 少数类被分类正确的样本数量，使得模型整体的精确性下降。

现在，如果我们的目的是模型整体的准确率，那我们就要拒绝样本平衡，使用class_weight被设置之前的模型。

然而在现实中，我们往往都在追求捕捉少数类，因为在很多情况下，将少数类判断错的代价是巨大的。

所以对我们来说，我们宁愿把多数类判错，也不想放过任何一个少数类。我们希望不惜一切代价来捕获少数类，或者希望捕捉出尽量多的少数类，那我们就必须使用class_weight设置后的模型。

2 SVC的模型评估指标

从上面的学习中可以看出，如果我们的目标是希望尽量捕获少数类，那准确率这个模型评估逐渐失效，所以我们需要新的模型评估指标来帮助我们。

如果简单来看，其实我们只需要查看模型在少数类上的准确率就好了，只要能够将少数类尽量捕捉出来，就能够达到我们的目的。

但此时，新问题又出现了，我们对多数类判断错误后，会需要人工甄别或者更多的业务上的措施来一一排除我们判断错误的多数类，这种行为往往伴随着很高的成本。

比如银行在判断”一个申请信用卡的客户是否会出现违约行为“的时候，如果一个客户被判断为”会违约“，这个客户的信用卡申请就会被驳回，如果为了捕捉出”会违约“的人，大量地将”不会违约“的客户判断为”会违约“的客户，就会有许多无辜的客户的申请被驳回。信用卡对银行来说意味着利息收入，而拒绝了许多本来不会违约的客户，对银行来说就是巨大的损失。

同理，大众在召回不符合欧盟标准的汽车时，如果为了找到所有不符合标准的汽车，而将一堆本来符合标准了的汽车召回，这个成本是不可估量的。也就是说，单纯地追求捕捉出少数类，就会成本太高，而不顾及少数类，又会无法达成模型的效果。

所以在现实中，我们往往在寻找捕获少数类的能力和将多数类判错后需要付出的成本的平衡。如果一个模型在能够尽量捕获少数类的情况下，还能够尽量对多数类判断正确，则这个模型就非常优秀了。

为了评估这样的能力，我们将引入新的模型评估指标：混淆矩阵和ROC曲线来帮助我们。

2.1 混淆矩阵（Confusion Matrix）

混淆矩阵是二分类问题的多维衡量指标体系，在样本不平衡时极其有用。在混淆矩阵中，我们将少数类认为是正例，多数类认为是负例。

在决策树，随机森林这些普通的分类算法里，即是说少数类是1，多数类是0。在SVM里，
就是说少数类是1，多数类是-1。普通的混淆矩阵，一般使用{0,1}来表示。

混淆矩阵中，永远是真实值在前，预测值在后。对角线就是全部预测错误的。基于混淆矩阵，我们有六个不同的模型评估指标，这些评估指标的范围都在[0,1]之间，所有以11和00为分子的指标都是越接近1越好，所以以01和10为分子的指标都是越接近0越好。

2.1.1 模型整体效果：准确率

对于所有的指标，我们用橙色表示分母，用绿色表示分子，则我们有：

准确率Accuracy就是所有预测正确的所有样本除以总样本，通常来说越接近1越好。

2.1.2 捕捉少数类的艺术：精确度，召回率和F1 score

精确度Precision，又叫查准率，表示所有被预测为是少数类的样本中，真正的少数类所占的比例。

在支持向量机中，精确度可以被形象地表示为决策边界上方的所有点中，红色点所占的比例。

• 精确度越高，代表我们捕捉正确的红色点越多，对少数类的预测越精确。
• 精确度越低，则代表我们误伤了过多的多数类。

精确度是”将多数类判错后所需付出成本“的衡量。

# 灰色线上的红色点/灰色以上的所有点
#所有判断正确并确实为1的样本 / 所有被判断为1的样本
#对于没有class_weight，没有做样本平衡的灰色决策边界来说：
(y[y == clf.predict(X)] == 1).sum()/(clf.predict(X) == 1).sum()
# 0.7142857142857143# 红色线上的红色点/红色以上的所有点
#对于有class_weight，做了样本平衡的红色决策边界来说：
(y[y == wclf.predict(X)] == 1).sum()/(wclf.predict(X) == 1).sum()
#0.5102040816326531

可以看出，做了样本平衡之后，精确度是下降的。因为很明显，样本平衡之后，有更多的多数类紫色点被我们误伤了。

精确度可以帮助我们判断，是否每一次对少数类的预测都精确，所以又被称为”查准率“。在现实的样本不平衡例子中，当每一次将多数类判断错误的成本非常高昂的时候（比如大众召回车辆的例子），我们会追求高精确度。精确度越低，我们对多数类的判断就会越错误。

当然了，如果我们的目标是不计一切代价捕获少数类，那我们并不在意精确度。

召回率Recall，又被称为敏感度(sensitivity)，真正率，查全率，表示所有真实为1的样本中，被我们预测正确的样本所占的比例。

在支持向量机中，召回率可以被表示为，决策边界上方的所有红色点占全部样本中的红色点的比例。

• 召回率越高，代表我们尽量捕捉出了越多的少数类，
• 召回率越低，代表我们没有捕捉出足够的少数类。

如果我们希望不计一切代价，找出少数类（比如找出潜在犯罪者的例子），那我们就会追求高召回率，相反如果我们的目标不是尽量捕获少数类，那我们就不需要在意召回率。

注意召回率和精确度的分子是相同的（都是11），只是分母不同。而召回率和精确度是此消彼长的，两者之间的平衡代表了捕捉少数类的需求和尽量不要误伤多数类的需求的平衡。究竟要偏向于哪一方，取决于我们的业务需求：究竟是误伤多数类的成本更高，还是无法捕捉少数类的代价更高。

为了同时兼顾精确度和召回率，我们创造了两者的调和平均数作为考量两者平衡的综合性指标，称之为F1 measure。两个数之间的调和平均倾向于靠近两个数中比较小的那一个数，因此我们追求尽量高的F1 measure，能够保证精确度和召回率都比较高。F1 measure在[0,1]之间分布，越接近1越好。

从Recall延申出来的另一个评估指标叫做假负率（False Negative Rate），它等于 1 - Recall，用于衡量所有真实为1的样本中，被我们错误判断为0的，通常用得不多。

2.1.3 判错多数类的考量：特异度与假正率

特异度(Specificity)表示所有真实为0的样本中，被正确预测为0的样本所占的比例。在支持向量机中，可以形象地表示为，决策边界下方的点占所有紫色点的比例。

#所有被正确预测为0的样本 / 所有的0样本
#对于没有class_weight，没有做样本平衡的灰色决策边界来说：
(y[y == clf.predict(X)] == 0).sum()/(y == 0).sum()#对于有class_weight，做了样本平衡的红色决策边界来说：
(y[y == wclf.predict(X)] == 0).sum()/(y == 0).sum()

特异度衡量了一个模型将多数类判断正确的能力，而1 - specificity就是一个模型将多数类判断错误的能力，这种能力被计算如下，并叫做假正率（False Positive Rate）：

在支持向量机中，假正率就是决策边界上方的紫色点（所有被判断错误的多数类）占所有紫色点的比例。

根据我们之前在precision处的分析，其实可以看得出来，当样本均衡过后，假正率会更高，因为有更多紫色点被判断错误，而样本均衡之前，假正率比较低，被判错的紫色点比较少。所以假正率其实类似于Precision的反向指标，Precision衡量有多少少数点被判断正确，而假正率FPR衡量有多少多数点被判断错误，性质是十分类似的。

2.1.4 sklearn中的混淆矩阵

sklearn当中提供了大量的类来帮助我们了解和使用混淆矩阵。

2.2 ROC曲线以及其相关问题

基于混淆矩阵，学习了总共六个指标：准确率Accuracy，精确度Precision，召回率Recall，精确度和召回度的平衡指标F measure，特异度Specificity，以及假正率FPR。

ROC曲线，全称The Receiver Operating Characteristic Curve，译为受试者操作特性曲线。这是一条以不同阈值下的假正率FPR为横坐标，不同阈值下的召回率Recall为纵坐标的曲线。

2.2.1 概率(probability)与阈值(threshold)

逻辑回归的 predict_proba 接口对每个样本生成每个标签类别下的似然（类概率）。对于这些似然，逻辑回归天然规定，当一个样本所对应的这个标签类别下的似然大于0.5的时候，这个样本就被分为这一类。

比如说，一个样本在标签1下的似然是0.6，在标签0下的似然是0.4，则这个样本的标签自然就被分为1。逻辑回归的回归值本身，其实也就是标签1下的似然。在这个过程中，0.5就被称为阈值。来看看下面的例子：

1. 自建数据集
class_1_ = 7
class_2_ = 4
centers_ = [[0.0, 0.0], [1,1]]
clusters_std = [0.5, 1]
X_, y_ = make_blobs(n_samples=[class_1_, class_2_],centers=centers_,cluster_std=clusters_std,random_state=0, shuffle=False)
plt.scatter(X_[:, 0], X_[:, 1], c=y_, cmap="rainbow",s=30)
plt.show()

2. 建模，调用概率
from sklearn.linear_model import LogisticRegression as LogiR
clf_lo = LogiR().fit(X_,y_)
prob = clf_lo.predict_proba(X_)
'''
array([[0.69461879, 0.30538121],[0.5109308 , 0.4890692 ],[0.82003826, 0.17996174],[0.78564706, 0.21435294],[0.77738721, 0.22261279],[0.65663421, 0.34336579],[0.76858638, 0.23141362],[0.34917129, 0.65082871],[0.36618382, 0.63381618],[0.66327186, 0.33672814],[0.6075288 , 0.3924712 ]])
'''
#将样本和概率放到一个DataFrame中
import pandas as pd
prob = pd.DataFrame(prob)
prob.columns = ["0","1"]
prob
'''0         1
0   0.694619  0.305381
1   0.510931  0.489069
2   0.820038  0.179962
3   0.785647  0.214353
4   0.777387  0.222613
5   0.656634  0.343366
6   0.768586  0.231414
7   0.349171  0.650829
8   0.366184  0.633816
9   0.663272  0.336728
10  0.607529  0.392471
'''
为0的概率为，为1的概率为

3. 使用阈值0.5，大于0.5的样本被预测为1，小于0.5的样本被预测为0
#手动调节阈值，来改变我们的模型效果
for i in range(prob.shape[0]):if prob.loc[i,"1"] > 0.5:prob.loc[i,"pred"] = 1else:prob.loc[i,"pred"] = 0prob
'''0         1  pred
0   0.694619  0.305381   0.0
1   0.510931  0.489069   0.0
2   0.820038  0.179962   0.0
3   0.785647  0.214353   0.0
4   0.777387  0.222613   0.0
5   0.656634  0.343366   0.0
6   0.768586  0.231414   0.0
7   0.349171  0.650829   1.0
8   0.366184  0.633816   1.0
9   0.663272  0.336728   0.0
10  0.607529  0.392471   0.0
'''
prob["y_true"] = y_
prob = prob.sort_values(by="1",ascending=False)
prob
'''0         1  pred  y_true
7   0.349171  0.650829   1.0       1
8   0.366184  0.633816   1.0       1
1   0.510931  0.489069   0.0       0
10  0.607529  0.392471   0.0       1
5   0.656634  0.343366   0.0       0
9   0.663272  0.336728   0.0       1
0   0.694619  0.305381   0.0       0
6   0.768586  0.231414   0.0       0
4   0.777387  0.222613   0.0       0
3   0.785647  0.214353   0.0       0
2   0.820038  0.179962   0.0       0
'''

4. 使用混淆矩阵查看结果
from sklearn.metrics import confusion_matrix as CM, precision_score as P, recall_score as R
CM(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])'''
array([[2, 2],[0, 7]], dtype=int64)
'''
#试试看手动计算Precision和Recall?
P(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0]) #  1.0
R(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0]) # 0.5

5. 假如我们使用0.4作为阈值呢？
for i in range(prob.shape[0]):if prob.loc[i,"1"] > 0.4:prob.loc[i,"pred"] = 1else:prob.loc[i,"pred"] = 0
CM(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])
'''
array([[2, 2],[1, 6]], dtype=int64)
'''
P(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])
R(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])
#注意，降低或者升高阈值并不一定能够让模型的效果变好，一切都基于我们要追求怎样的模型效果

可见，在不同阈值下，我们的模型评估指标会发生变化，我们正利用这一点来观察Recall和FPR之间如何互相影响。但是注意，并不是升高阈值，就一定能够增加或者减少Recall，一切要根据数据的实际分布来进行判断。而要体现阈值的影响，首先必须的得到分类器在少数类下的预测概率。

2.2.2 SVM实现概率预测：重要参数probability，接口predict_proba以及decision_function

在SVM中利用超平面来判断我们的样本，本质上来说，当两个点的距离是相同的符号的时候，越远离超平面的样本点归属于某个标签类的概率就很大。

某个点到超平面的距离一定程度上反应了样本归属于某个标签类的可能性。接口decision_function返回的值也因此被认为是SVM中的置信度（confidence）。

不过，置信度始终不是概率，它没有边界，可以无限大，大部分时候也不是以百分比或者小数的形式呈现，而SVC的判断过程又不像决策树一样可以求解出一个比例。为了解决这个矛盾，SVC有重要参数probability。

参数	含义
probability	布尔值，可不填，默认False 是否启用概率估计。进行必须在调用fit之前启用它，启用此功能会减慢SVM的运算速度。 设置为True则会启动，启用之后，SVC的接口predict_proba和predict_log_proba将生效。 在二分类情况下，SVC将使用Platt缩放来生成概率，即在decision_function生成的距离上进行Sigmoid压缩，并附加训练数据的交叉验证拟合，来生成类逻辑回归的SVM分数。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import svm
from sklearn.datasets import make_circles, make_moons, make_blobs,make_classification#使用最初的X和y，样本不均衡的这个模型class_1 = 500 #类别1有500个样本
class_2 = 50 #类别2只有50个
centers = [[0.0, 0.0], [2.0, 2.0]] #设定两个类别的中心
clusters_std = [1.5, 0.5] #设定两个类别的方差，通常来说，样本量比较大的类别会更加松散
X, y = make_blobs(n_samples=[class_1, class_2],centers=centers,cluster_std=clusters_std,random_state=0, shuffle=False)
#看看数据集长什么样
plt.scatter(X[:, 0], X[:, 1], c=y, cmap="rainbow",s=10)

#其中红色点是少数类，紫色点是多数类
clf_proba = svm.SVC(kernel="linear",C=1.0,probability=True).fit(X,y)
clf_proba.predict_proba(X).shape #生成的各类标签下的概率
'''
array([[0.69755412, 0.30244588],[0.31564851, 0.68435149],[0.95331469, 0.04668531],...,[0.20423871, 0.79576129],[0.4043668 , 0.5956332 ],[0.36398833, 0.63601167]])
'''
# (550, 2)clf_proba.decision_function(X)  
clf_proba.decision_function(X).shape #  (550,)

值得注意的是，在二分类过程中，decision_function只会生成一列距离，样本的类别由距离的符号来判断，但是predict_proba会生成两个类别分别对应的概率。SVM也可以生成概率，所以我们可以使用和逻辑回归同样的方式来在SVM上设定和调节我们的阈值。

2.2.3 绘制SVM的ROC曲线

ROC曲线，全称The Receiver Operating Characteristic Curve，译为受试者操作特性曲线。这是一条以不同阈值下的假正率FPR为横坐标，不同阈值下的召回率Recall为纵坐标的曲线。

ROC曲线主要是用于X对Y的预测准确率情况

在支持向量机中，召回率可以被表示为，决策边界上方的所有红色点占全部样本中的红色点的比例。

在支持向量机中，假正率就是决策边界上方的紫色点（所有被判断错误的多数类）占所有紫色点的比例。

要绘制ROC曲线，就必须在我们的数据中去不断调节阈值，不断求解混淆矩阵，然后不断获得我们的横坐标和纵坐标，最后才能够将曲线绘制出来。

首先来看看如何从混淆矩阵中获取FPR和Recall

#首先来看看如何从混淆矩阵中获取FPR和Recall
cm = CM(prob.loc[:,"y_true"],prob.loc[:,"pred"],labels=[1,0])
'''
array([[2, 2],[1, 6]], dtype=int64)
'''
#00/all true 0 1-特异度
#FPR #被我们预测错误的0占所有真正为0的样本的比例
cm[1,0]/cm[1,:].sum()
#Recall
cm[0,0]/cm[0,:].sum()

#概率 clf_proba.predict_proba(X)[:,1] #我的类别1下面的概率
#阈值，每一个阈值都对应着一次循环，每一次循环，都要有一个混淆矩阵，要有一组假正率vsRecall
#np.lispance(概率最小值，概率最大值，55，endpoint=False) #不要取到最大值
#if i > 概率最大值, 返回1
#开始绘图
probrange = np.linspace(clf_proba.predict_proba(X)[:,1].min(),clf_proba.predict_proba(X)[:,1].max(),num=50,endpoint=False)from sklearn.metrics import confusion_matrix as CM, recall_score as R
import matplotlib.pyplot as plotrecall = []
FPR = []for i in probrange:y_predict = []for j in range(X.shape[0]):if clf_proba.predict_proba(X)[j,1] > i:y_predict.append(1)else:y_predict.append(0)cm = CM(y,y_predict,labels=[1,0])recall.append(cm[0,0]/cm[0,:].sum())FPR.append(cm[1,0]/cm[1,:].sum())recall.sort()
FPR.sort()plt.plot(FPR,recall,c="red")
plt.plot(probrange+0.05,probrange+0.05,c="black",linestyle="--")
plt.show()

建立ROC曲线的目的是找寻Recall和FPR之间的平衡，让我们能够衡量模型在尽量捕捉少数类的时候，误伤多数类的情况会如何变化。

• 横坐标是FPR，代表着模型将多数类判断错误的能力，
• 纵坐标Recall，代表着模型捕捉少数类的能力

所以ROC曲线代表着，随着Recall的不断增加，FPR如何增加。我们希望随着Recall的不断提升，FPR增加得越慢越好，这说明我们可以尽量高效地捕捉出少数类，而不会将很多地多数类判断错误。

所以，我们希望看到的图像是，纵坐标急速上升，横坐标缓慢增长，也就是在整个图像左上方的一条弧线。这代表模型的效果很不错，拥有较好的捕获少数类的能力。

---

中间的虚线代表着，当recall增加1%，FPR也增加1%，也就是说，每捕捉出一个少数类，就会有一个多数类被判错，这种情况下，模型的效果就不好，这种模型捕获少数类的结果，会让许多多数类被误伤，从而增加我们的成本。

ROC曲线通常都是凸型的。对于一条凸型ROC曲线来说，曲线越靠近左上角越好，越往下越糟糕，曲线如果在虚线的下方，则证明模型完全无法使用。

但是它也有可能是一条凹形的ROC曲线。对于一条凹型ROC曲线来说，应该越靠近右下角越好，凹形曲线代表模型的预测结果与真实情况完全相反，那也不算非常糟糕，只要我们手动将模型的结果逆转，就可以得到一条左上方的弧线了。

最糟糕的就是，无论曲线是凹形还是凸型，曲线位于图像中间，和虚线非常靠近，那我们拿它无能为力。

2.2.4 sklearn中的ROC曲线和AUC面积

现在有了这条曲线，知道模型的效果还算是不错了。但依然非常摸棱两可，有没有具体的数字来帮助理解ROC曲线和模型的效果呢？

这个数字就叫做AUC面积，它代表了ROC曲线下方的面积，这个面积越大，代表ROC曲线越接近左上角，模型就越好。

---

在sklearn中，有帮助计算ROC曲线的横坐标假正率FPR，纵坐标Recall和对应的阈值的类sklearn.metrics.roc_curve。计算AUC面积的类sklearn.metrics.roc_auc_score。

sklearn.metrics.roc_curve (y_true, y_score, pos_label=None, sample_weight=None, drop_intermediate=True)

y_true : 数组，形状 = [n_samples]，真实标签
y_score : 数组，形状 = [n_samples]，置信度分数，可以是正类样本的概率值，或置信度分数，或者decision_function返回的距离
pos_label : 整数或者字符串, 默认None，表示被认为是正类样本的类别
sample_weight : 形如 [n_samples]的类数组结构，可不填，表示样本的权重
drop_intermediate : 布尔值，默认True，如果设置为True，表示会舍弃一些ROC曲线上不显示的阈值点，这对于计算一个比较轻量的ROC曲线来说非常有用

在SVM中利用超平面来判断我们的样本，本质上来说，当两个点的距离是相同的符号的时候，越远离超平面的样本点归属于某个标签类的概率就很大。

某个点到超平面的距离一定程度上反应了样本归属于某个标签类的可能性。接口decision_function返回的值也因此被认为是SVM中的置信度（confidence）。

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.colors import ListedColormap
from sklearn import svm
from sklearn.datasets import make_circles, make_moons, make_blobs,make_classification#使用最初的X和y，样本不均衡的这个模型class_1 = 500 #类别1有500个样本
class_2 = 50 #类别2只有50个
centers = [[0.0, 0.0], [2.0, 2.0]] #设定两个类别的中心
clusters_std = [1.5, 0.5] #设定两个类别的方差，通常来说，样本量比较大的类别会更加松散
X, y = make_blobs(n_samples=[class_1, class_2],centers=centers,cluster_std=clusters_std,random_state=0, shuffle=False)
#看看数据集长什么样
plt.scatter(X[:, 0], X[:, 1], c=y, cmap="rainbow",s=10)#其中红色点是少数类，紫色点是多数类
clf_proba = svm.SVC(kernel="linear",C=1.0,probability=True).fit(X,y)
clf_proba.predict_proba(X).shape #生成的各类标签下的概率
'''
array([[0.69755412, 0.30244588],[0.31564851, 0.68435149],[0.95331469, 0.04668531],...,[0.20423871, 0.79576129],[0.4043668 , 0.5956332 ],[0.36398833, 0.63601167]])
'''
# (550, 2)clf_proba.decision_function(X)  
clf_proba.decision_function(X).shape #  (550,)

from sklearn.metrics import roc_curve
FPR, recall, thresholds = roc_curve(y,clf_proba.decision_function(X), pos_label=1)
FPR
recall
thresholds #此时的threshold就不是一个概率值，而是距离值中的阈值了，所以它可以大于1，也可以为负

这个类以此返回：FPR，Recall以及阈值。

---

sklearn.metrics.roc_auc_score (y_true, y_score, average=’macro’, sample_weight=None, max_fpr=None)

AUC面积的分数使用以上类来进行计算，输入的参数为真实标签，和与roc_curve中一致的置信度分数或者概率值。

from sklearn.metrics import roc_auc_score as AUC
area = AUC(y,clf_proba.decision_function(X))
#  0.9696400000000001
# 越靠近1，模型越好

plt.figure()
plt.plot(FPR, recall, color='red',label='ROC curve (area = %0.2f)' % area)
plt.plot([0, 1], [0, 1], color='black', linestyle='--')
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('Recall')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()

在无法获取模型概率的情况下，其实不必强行使用概率，如果有置信度，那也使可以完成我们的ROC曲线的。

在SVM中利用超平面来判断我们的样本，本质上来说，当两个点的距离是相同的符号的时候，越远离超平面的样本点归属于某个标签类的概率就很大。

某个点到超平面的距离一定程度上反应了样本归属于某个标签类的可能性。接口decision_function返回的值也因此被认为是SVM中的置信度（confidence）。

2.2.5 利用ROC曲线找出最佳阈值

ROC曲线反应的是recall增加的时候FPR如何变化，也就是当模型捕获少数类的能力变强的时候，会误伤多数类的情况是否严重。

我们的希望是模型在捕获少数类的能力变强的时候，尽量不误伤多数类，也就是说，随着recall的变大，FPR的大小越小越好。所以我们希望找到的最优点，其实是Recall和FPR差距最大的点。这个点，又叫做约登指数。

maxindex = (recall - FPR).tolist().index(max(recall - FPR))
# 43
thresholds[maxindex]
#-1.0860191749391461#可以在图像上来看看这个点在哪里
plt.scatter(FPR[maxindex],recall[maxindex],c="black",s=30)#把上述代码放入这段代码中：
plt.figure()
plt.plot(FPR, recall, color='red',label='ROC curve (area = %0.2f)' % area)
plt.plot([0, 1], [0, 1], color='black', linestyle='--')
plt.scatter(FPR[maxindex],recall[maxindex],c="black",s=30)
plt.xlim([-0.05, 1.05])
plt.ylim([-0.05, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('Recall')
plt.title('Receiver operating characteristic example')
plt.legend(loc="lower right")
plt.show()

最佳阈值就这样选取出来了，由于现在使用decision_function来画ROC曲线，所以我们选择出来的最佳阈值其实是最佳距离。

如果使用的是概率，选取的最佳阈值就会使一个概率值了。只要让这个距离/概率以上的点，都为正类，让这个距离/概率以下的点都为负类，模型就是最好的：即能够捕捉出少数类，又能够尽量不误伤多数类，整体的精确性和对少数类的捕捉都得到了保证。

而从找出的最优阈值点来看，这个点，其实是图像上离左上角最近的点，离中间的虚线最远的点，也是ROC曲线的转折点。如果没有时间进行计算，或者横坐标比较清晰的时候，就可以观察转折点来找到我们的最佳阈值。

3 使用SVC时的其他考虑

3.1 SVC处理多分类问题