属性和参数

参数

• C: float参数 默认值为1.0
  错误项的惩罚系数。C越大，即对分错样本的惩罚程度越大，因此在训练样本中准确率越高，但是泛化能力降低，也就是对测试数据的分类准确率降低。相反，减小C的话，容许训练样本中有一些误分类错误样本，泛化能力强。对于训练样本带有噪声的情况，一般采用后者，把训练样本集中错误分类的样本作为噪声。

• kernel: str参数 默认为‘rbf’
  算法中采用的核函数类型，可选参数有：
  ‘linear’:线性核函数
  ‘poly’：多项式核函数
  ‘rbf’：径像核函数/高斯核
  ‘sigmod’:sigmod核函数
  ‘precomputed’:核矩阵

• degree: int型参数 默认为3
  这个参数只对多项式核函数有用，是指多项式核函数的阶数n
  如果给的核函数参数是其他核函数，则会自动忽略该参数。

• gamma: float参数 默认为auto
  核函数系数，只对‘rbf’,‘poly’,‘sigmod’有效。
  如果gamma为auto，代表其值为样本特征数的倒数，即1/n_features.

• coef0: float参数 默认为0.0
  核函数中的独立项，只有对‘poly’和‘sigmod’核函数有用，是指其中的参数c

• probability： bool参数 默认为False
  是否启用概率估计。 这必须在调用fit()之前启用，并且会fit()方法速度变慢。

• shrinking： bool参数 默认为True
  是否采用启发式收缩方式

• tol: float参数 默认为1e^-3
  svm停止训练的误差精度

• cache_size： float参数 默认为200
  指定训练所需要的内存，以MB为单位，默认为200MB。

• class_weight： 字典类型或者‘balance’字符串。默认为None
  给每个类别分别设置不同的惩罚参数C，如果没有给，则会给所有类别都给C=1，即前面参数指出的参数C.
  如果给定参数‘balance’，则使用y的值自动调整与输入数据中的类频率成反比的权重。

• verbose： bool参数 默认为False
  是否启用详细输出。 此设置利用libsvm中的每个进程运行时设置，如果启用，可能无法在多线程上下文中正常工作。一般情况都设为False，不用管它。

• max_iter： int参数 默认为-1
  最大迭代次数，如果为-1，表示不限制

• random_state： int型参数 默认为None
  伪随机数发生器的种子,在混洗数据时用于概率估计。

• ★fit() 方法：用于训练SVM，具体参数已经在定义SVC对象的时候给出了，这时候只需要给出数据集X和X对应的标签y即可。

• ★predict() 方法: 基于以上的训练，对预测样本T进行类别预测，因此只需要接收一个测试集T，该函数返回一个数组表示个测试样本的类别。

• ★属性有哪些：

  • svc.n_support_：各类各有多少个支持向量

  • svc.support_：各类的支持向量在训练样本中的索引

  • svc.support_vectors_：各类所有的支持向量

示例

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets, linear_model, model_selection, svm

iris = datasets.load_iris()
X_train = iris.data
y_train = iris.target
X_train, X_test, y_train, y_test = model_selection.train_test_split(X_train, y_train, test_size=0.25, random_state=0, stratify=y_train)

cls = svm.SVC(kernel='linear')
cls.fit(X_train, y_train)
print('Coefficients:%s, intercept %s' % (cls.coef_, cls.intercept_))
print('Score: %.2f' % cls.score(X_test, y_test))

poly + degree

fig = plt.figure()

degrees = range(1, 20)
train_scores = []
test_scores = []
for degree in degrees:
    cls = svm.SVC(kernel='poly', degree=degree)
    cls.fit(X_train, y_train)
    train_scores.append(cls.score(X_train, y_train))
    test_scores.append(cls.score(X_test, y_test))

ax = fig.add_subplot(1, 3, 1)
ax.plot(degrees, train_scores, label="Training score ", marker='+')
ax.plot(degrees, test_scores, label=" Testing  score ", marker='o')
ax.set_title("SVC_poly_degree ")
ax.set_xlabel("p")
ax.set_ylabel("score")
ax.set_ylim(0, 1.05)
ax.legend(loc="best", framealpha=0.5)

gammas = range(1, 20)
train_scores = []
test_scores = []
for gamma in gammas:
    cls = svm.SVC(kernel='poly', gamma=gamma, degree=3)
    cls.fit(X_train, y_train)
    train_scores.append(cls.score(X_train, y_train))
    test_scores.append(cls.score(X_test, y_test))
ax = fig.add_subplot(1, 3, 2)
ax.plot(gammas, train_scores, label="Training score ", marker='+')
ax.plot(gammas, test_scores, label=" Testing  score ", marker='o')
ax.set_title("SVC_poly_gamma ")
ax.set_xlabel(r"$\gamma$")
ax.set_ylabel("score")
ax.set_ylim(0, 1.05)
ax.legend(loc="best", framealpha=0.5)

rs = range(0, 20)
train_scores = []
test_scores = []
for r in rs:
    cls = svm.SVC(kernel='poly', gamma=10, degree=3, coef0=r)
    cls.fit(X_train, y_train)
    train_scores.append(cls.score(X_train, y_train))
    test_scores.append(cls.score(X_test, y_test))
ax = fig.add_subplot(1, 3, 3)
ax.plot(rs, train_scores, label="Training score ", marker='+')
ax.plot(rs, test_scores, label=" Testing  score ", marker='o')
ax.set_title("SVC_poly_r ")
ax.set_xlabel(r"r")
ax.set_ylabel("score")
ax.set_ylim(0, 1.05)
ax.legend(loc="best", framealpha=0.5)
plt.show()

rbf + gamma

gammas = range(1, 20)
train_scores = []
test_scores = []
for gamma in gammas:
    cls = svm.SVC(kernel='rbf', gamma=gamma)
    cls.fit(X_train, y_train)
    train_scores.append(cls.score(X_train, y_train))
    test_scores.append(cls.score(X_test, y_test))
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
ax.plot(gammas, train_scores, label="Training score ", marker='+')
ax.plot(gammas, test_scores, label=" Testing  score ", marker='o')
ax.set_title("SVC_rbf")
ax.set_xlabel(r"$\gamma$")
ax.set_ylabel("score")
ax.set_ylim(0, 1.05)
ax.legend(loc="best", framealpha=0.5)
plt.show()

sigmoid + gamma + coef

fig = plt.figure()

gammas = np.logspace(-2, 1)
train_scores = []
test_scores = []

for gamma in gammas:
    cls = svm.SVC(kernel='sigmoid', gamma=gamma, coef0=0)
    cls.fit(X_train, y_train)
    train_scores.append(cls.score(X_train, y_train))
    test_scores.append(cls.score(X_test, y_test))
ax = fig.add_subplot(1, 2, 1)
ax.plot(gammas, train_scores, label="Training score ", marker='+')
ax.plot(gammas, test_scores, label=" Testing  score ", marker='o')
ax.set_title("SVC_sigmoid_gamma ")
ax.set_xscale("log")
ax.set_xlabel(r"$\gamma$")
ax.set_ylabel("score")
ax.set_ylim(0, 1.05)
ax.legend(loc="best", framealpha=0.5)

rs = np.linspace(0, 5)
train_scores = []
test_scores = []

for r in rs:
    cls = svm.SVC(kernel='sigmoid', coef0=r, gamma=0.01)
    cls.fit(X_train, y_train)
    train_scores.append(cls.score(X_train, y_train))
    test_scores.append(cls.score(X_test, y_test))
ax = fig.add_subplot(1, 2, 2)
ax.plot(rs, train_scores, label="Training score ", marker='+')
ax.plot(rs, test_scores, label=" Testing  score ", marker='o')
ax.set_title("SVC_sigmoid_r ")
ax.set_xlabel(r"r")
ax.set_ylabel("score")
ax.set_ylim(0, 1.05)
ax.legend(loc="best", framealpha=0.5)
plt.show()

1.SVM简介

支持向量机（Support Vector Machine, SVM）是一类按监督学习（supervised learning）方式对数据进行二元分类（binary classification）的广义线性分类器（generalized linear classifier），其决策边界是对学习样本求解的最大边距超平面（maximum-margin hyperplane）。
SVM的基本思想是：找到集合边缘上的若干数据（称为支持向量（Support Vector）），用这些点找出一个平面（称为决策面），使得支持向量到该平面的距离最大。

2.SVM参数意义

在sklearn中，封装好各种机器学习的库，其中就包含SVM算法，其调用如下：

import sklearn.svm as svm
model = svm.SVC(C=1.0,
 kernel='rbf', 
degree=3, 
gamma='auto',
 coef0=0.0, 
shrinking=True,
 probability=False,
tol=0.001, 
cache_size=200, c
lass_weight=None, 
verbose=False, 
max_iter=-1, 
decision_function_shape=None,
random_state=None)

参数说明：
C：SVC的惩罚参数，默认值是1.0；C越大，对误分类的惩罚增大，趋向于对训练集完全分对的情况，这样对训练集测试时准确率很高，但泛化能力弱。C值小，对误分类的惩罚减小，允许容错，将他们当成噪声点，泛化能力较强。

关于松弛变量，我这边要解释下：
在大多数情况下，数据并不是完美的线性可分数据，可能会存在少量的点出现在分类超平面的另外一侧。我们希望尽量保证将这些点进行正确分类，同时又保证分类面与两类样本点有足够大的几何间隔。在这种情况下，我们为每一个样本点加上一个松弛变量，允许有小的误差存在。在加入松弛变量后，我们还要在目标函数中加入相应的惩罚参数C，对这个松弛变量起到一个监督克制的作用。两者的关系，有点类似道家的阴阳制衡的关系，此消彼长。

kernel ：核函数，默认是rbf，可以是‘linear’, ‘poly’, ‘rbf’, ‘sigmoid’, ‘precomputed’
linear：线性分类器（C越大分类效果越好，但有可能会过拟合（default C=1））
poly：多项式分类器
rbf：高斯模型分类器（gamma值越小，分类界面越连续；gamma值越大，分类界面越“散”，分类效果越好，但有可能会过拟合。）
sigmoid：sigmoid核函数
具体可以参考：https://zhuanlan.zhihu.com/p/157722218
degree ：多项式poly函数的维度，默认是3，选择其他核函数时会被忽略。
gamma ： ‘rbf’,‘poly’ 和‘sigmoid’的核函数参数。默认是’auto’。 如果gamma是’auto’，那么实际系数是1 / n_features。
coef0 ：核函数中的独立项。 它只在’poly’和’sigmoid’中很重要。
probability ：是否启用概率估计。 必须在调用fit之前启用它，并且会减慢该方法的速度。默认为False
shrinking ：是否采用shrinking heuristic方法(收缩启发式)，默认为true
tol ：停止训练的误差值大小，默认为1e-3
cache_size ：核函数cache缓存大小，默认为200
class_weight ：类别的权重，字典形式传递。设置第几类的参数C为weight*C(C-SVC中的C)
verbose ：允许冗余输出
max_iter ：最大迭代次数。-1为无限制。
decision_function_shape ：‘ovo’, ‘ovr’ or None, default=ovr
关于‘ovo’, ‘ovr’的解释：
一对多法（one-versus-rest,简称OVR SVMs）：训练时依次把某个类别的样本归为一类,其他剩余的样本归为另一类，这样k个类别的样本就构造出了k个SVM。分类时将未知样本分类为具有最大分类函数值的那类。
一对一法（one-versus-one,简称OVO SVMs或者pairwise）：其做法是在任意两类样本之间设计一个SVM，因此k个类别的样本就需要设计k(k-1)/2个SVM。当对一个未知样本进行分类时，最后得票最多的类别即为该未知样本的类别。
详细讲解，可以参考这篇博客：https://blog.csdn.net/xfchen2/article/details/79621396
random_state ：数据洗牌时的种子值，int值,default=None
在随机数据混洗时使用的伪随机数生成器的种子。 如果是int，则random_state是随机数生成器使用的种子; 如果是RandomState实例，则random_state是随机数生成器; 如果为None，则随机数生成器是np.random使用的RandomState实例。
个人认为最重要的参数有：C、kernel、degree、gamma、coef0、decision_function_shape。

3.sklearn中SVM接口调用

# 建立模型
model = svm.SVC(C=10, kernel='linear')

# 训练模型,x为训练集， y为标签
model.fit(x, y)

# 预测,test为测试集
pre_y = model.predict(test)

# 预测结果数据
n_Support_vector = clf.n_support_  # 支持向量个数
sv_idx = clf.support_  # 支持向量索引
Support_vector = clf.support_vectors_   # 支持向量
w = clf.coef_  # 权重矩阵W
b = clf.intercept_  # 偏置矩阵b

4.代码实现

运行环境：pycharm、scikit-learn 0.23.2

import numpy as np
import joblib
from sklearn import svm
import matplotlib.pyplot as plt
x = [[1, 2], [4, 5], [18, 9], [12, 6], [2, 3], [13, 18]]
x = np.array(x)
y = [1, 1, 0, 0, 1, 0]
y = np.array(y)
# 训练模型
model = svm.SVC(C=10, kernel='linear')
model.fit(x, y)

# 预测
a = [[8, 6]]
a_pre = model.predict(a)
print("a_pre:", a_pre)
# 对应的支持向量
Support_vector = model.support_vectors_
print("Support_vector:", Support_vector)
# 线性分类对应的参数
w = model.coef_
print("w:", w)
b = model.intercept_
print("b:", b)
# 训练集散点图
plt.scatter(x[:, 0], x[:, 1])

if w[0, 1] != 0:
    xx = np.arange(0, 20, 0.1)
    # 最佳分类线
    yy = -w[0, 0]/w[0, 1] * xx - b/w[0, 1]
    plt.scatter(xx, yy, s=4)
    # 支持向量
    b1 = Support_vector[0, 1] + w[0, 0]/w[0, 1] * Support_vector[0, 0]
    b2 = Support_vector[1, 1] + w[0, 0]/w[0, 1] * Support_vector[1, 0]
    yy1 = -w[0, 0] / w[0, 1] * xx + b1
    plt.scatter(xx, yy1, s=4)
    yy2 = -w[0, 0] / w[0, 1] * xx + b2
    plt.scatter(xx, yy2, s=4)
else:
    xx = np.ones(100) * (-b) / w[0, 0]
    yy = np.arange(0, 10, 0.1)
    plt.scatter(xx, yy)
plt.show()

查阅sklearn官方文档可知，predict_log_proba(X)这个函数计算X中的样本可能结果的概率。但是该概率的计算使用交叉验证创建概率模型，因此结果可以略有不同于预测获得的模型。此外，它将在非常小的数据集上产生毫无意义的结果。