三、SVM基础

SVM理论学习

支持向量机(SVM)是一类经典的机器学习算法，给定训练集D={(x₁,y₁),(x₂,y₂),…,(x_n,y_n)},y_i∈{-1,1}，支持向量机试图找到一个平面把样本给分隔开，这个平面叫划分超平面w^Tx+b = 0的划分超平面。样本点x_i到超平面w^Tx+b=0的距离为r(x_i)，距离超平面最近的几个训练样本点称为支持向量，两个不同类别的支持向量到超平面的距离之和r = 2/||w||称为间隔。

假设我们得到了一个划分超平面w^Tx+b = 0，那么：
$$\begin{gathered} w^T{x}_i+b\le -1,y_i=-1 \\ {w}^T{x}_i+b\ge -1,y_i=+1 \end{gathered}$$
则求解最大间隔划分超平面对应于优化问题：
$$\begin{gathered} \underset{w,b}{\min }\frac{1}{2}||w|{|}^2 \\ s.t.y_i(w^T{x}_i+b)\ge 1(i\in [m]) \end{gathered}$$
通过这个问题我们可以得到一个拉格朗日函数(不懂的请看我之前的博客)
$$L(w,b,\alpha )=\frac{1}{2}||w|{|}^2+\sum _{i=1}^m{a}_i(1-y_i(w^T{x}_i+b))(i\in [m])$$
其中拉格朗日乘子α_i>=0,对函数未知量进行偏导等于0可得：
$$\begin{gathered} w=\sum _{i=1}^m{a}_i{y}_i{x}_i \\ \sum _{i=1}^m{a}_i{y}_i=0 \end{gathered}$$
把上面得到的三个式子联立，经过转化可以得到主问题的对偶问题：
$$\begin{gathered} \underset{\alpha }{\min }\frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_j{x}_i^T{x}_j-\sum _{i=1}^m{\alpha }_i \\ s.t.\sum _{i=1}^m{\alpha }_i{y}_i=0;{\alpha }_i\ge 0(i\in [m]) \end{gathered}$$
上述过程满足KKT条件：
$$\begin{gathered} \sum _{i=1}^m{a}_i{y}_i{x}_i=w; \\ su{m}_{i=1}^m{\alpha }_i{y}_i=0; \\ {\alpha }_i\ge 0; \\ {y}_i(w^T{x}_i+b)-1\ge 0; \\ {a}_i(1-y_i(w^T{x}_i+b))=0. \end{gathered}$$
如果数据是分布在曲线两侧怎么办？
比如数据在y=x²上面跟下面用划分超平面无法简单划分在低维空间线性不可分，就把数据扩充到高维。

进行计算两多维变量距离的时候，有时候扩展到高维后使计算很困难，为此我们需要考虑核函数。
$$\kappa （x_i,x_j)=<\varphi （x_i),\varphi (x_j)>=\varphi （x_i{)}^T\varphi (x_j)$$
x_i跟x_j在特征空间中的内积等于它们在原始样本空间中通过函数k(‘，’）计算的结果，这样就不必直接去计算高维甚至无穷维度特征中的内积，于是可以把公式改为：

$$\begin{gathered} \underset{\alpha }{\min }\frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_j\kappa （x_i,x_j)-\sum _{i=1}^m{\alpha }_i \\ s.t.\sum _{i=1}^m{\alpha }_i{y}_i=0 \\ {\alpha }_i\ge 0(i\in [m]) \end{gathered}$$
核函数的定义：令X为输入空间，k(‘，’）是定义在X×X上的对称函数，则k是核函数当且仅当对于任意数据{x₁,x₂…x_n},核矩阵K是一个半正定的m阶方阵，K_ij=k(x_i，x_j）

名称	表达式	参数
线性核	$$\kappa （x_i,x_j)=x_i^T{x}_j$$
多项式核	$$\kappa （x_i,x_j)=(x_i^T{x}_j{)}^d$$	d>=1为多项式的次数
高斯核	$$\kappa （x_i,x_j)=e^{-\frac{\Vert x_1-x_2{\Vert }^2}{2{\sigma }^2}}$$	σ>0且为高斯核的带宽
拉普拉斯核	$$\kappa （x_i,x_j)=e^{-\frac{\Vert x_1-x_2\Vert }{2{\sigma }^2}}$$	σ>0
sigmoid核	$$\kappa （x_i,x_j)=tanh(\beta x_i^T{x}_j+\theta )$$	tanh为双曲正切函数，β＞0，θ<0

每个核函数都隐式定义了一个特征空间，称为再生核希尔伯特空间，核函数的选择会影响SVM的性能。
在现实的工作中很难让训练样本的特征空间线性可分，但是在现实工作中很难确定合适的核函数使得训练样本在特征空间中线性可分，可能是欠拟合或者过拟合造成的？
为此引入软间隔的概念，允许一小部分样本分类错误。在最大间隔的同时，让不满足约束的样本尽可能少，于是优化的目标函数可以写成：
$$\begin{gathered} mi{n}_{w,b}\frac{1}{2}||w|{|}^2+\beta \sum _{i=1}^m{l}_{0/1}(y_i(w^T\varphi (x_i)+b)-1) \\ \beta >0 \\ {l}_{0/1}(x)=I(x<0) \end{gathered}$$
当β很大的时候，被迫使所有的样本全部满足，原先的定义，当β有限的时候，运行一部分样本不满足约束。
因为l_0/1非凸不联系，因此我们用hinge损失作为替代l_0/1，叫做替代损失。
$$l_{hinge(x)}=\max (0,1-x)$$
优化目标函数的公式可以变为：
$$\begin{gathered} mi{n}_{w,b}\frac{1}{2}||w|{|}^2+\beta \sum _{i=1}^m\max (0,1-y_i(w^T\varphi (x_i)+b)) \\ \beta >0 \\ {l}_{0/1}(x)=I(x<0) \end{gathered}$$
引入松弛变量ξ_i>=0,那么优化目标的公式可以变为：
$$\begin{gathered} mi{n}_{w,b}\frac{1}{2}||w|{|}^2+\beta \sum _{i=1}^m{\xi }_i \\ s.t.y_i(w^T\varphi (x_i)+b)\ge 1-{\xi }_i \\ {\xi }_i\ge 0(i\in [m]) \end{gathered}$$
这个目标函数的相应的对偶问题为：
$$\begin{gathered} \underset{\alpha }{\min }\frac{1}{2}\sum _{i=1}^m\sum _{j=1}^m{\alpha }_i{\alpha }_j{y}_i{y}_j\kappa （x_i,x_j)-\sum _{i=1}^m{\alpha }_i \\ s.t.\sum _{i=1}^m{\alpha }_i{y}_i=0 \\ \beta \ge {\alpha }_i\ge 0(i\in [m]) \end{gathered}$$
最后总结SVM的优点与缺点
优点：

• 在高维空间与大量数据的实战中效果依旧不错。
• 在决策函数重使用训练集的子集，是高效利用内存的。
• 不同的核函数可以得到不同的决策函数，对不同的问题都有较好的适应能力。

缺点：

• 特征数量不要大于样本数量。
• 支持向量机不直接提供概率估计,这些都是使用昂贵的五次交叉验算计算的。

代码：

1.用库实现

（1）分类问题

下面代码中我们用到了svc,在这里简单解释一下。
SVC(Support Vector Classification)就是支持向量机用于分类

'''
SVC参数解释
（1）C: 目标函数的惩罚系数C，用来平衡分类间隔margin和错分样本的，default C = 1.0；
（2）kernel：参数选择有RBF, Linear, Poly, Sigmoid, 默认的是"RBF";
（3）degree：if you choose 'Poly' in param 2, this is effective, degree决定了多项式的最高次幂；
（4）gamma：核函数的系数('Poly', 'RBF' and 'Sigmoid'), 默认是gamma = 1 / n_features;
（5）coef0：核函数中的独立项，'RBF' and 'Poly'有效；
（6）probablity: 可能性估计是否使用(true or false)；
（7）shrinking：是否进行启发式；
（8）tol（default = 1e - 3）: svm结束标准的精度;
（9）cache_size: 制定训练所需要的内存（以MB为单位）；
（10）class_weight: 每个类所占据的权重，不同的类设置不同的惩罚参数C, 缺省的话自适应；
（11）verbose: 跟多线程有关，不大明白啥意思具体；
（12）max_iter: 最大迭代次数，default = 1， if max_iter = -1, no limited;
（13）decision_function_shape ： ‘ovo’ 一对一, ‘ovr’ 多对多  or None 无, default=None
（14）random_state ：用于概率估计的数据重排时的伪随机数生成器的种子。
 ps：7,8,9一般不考虑。
'''
from sklearn import svm
X = [[1,3], [-1,-3]]
Y = [0, 1]
clf = svm.SVC(gamma='scale')
clf.fit(X, Y) 
answer = clf.predict([[2, 2]])
print(clf.decision_function(X))#得到到分离超平面的距离

然后再说一下NuSVC（Nu-Support Vector Classification.)

'''
NuSVC参数
nu：训练误差的一个上界和支持向量的分数的下界。应在间隔（0，1 ]。
其余同SVC
'''
from sklearn import svm
X = [[0, 0], [2, 2],[0, 3],[4, 2]]
y = [0, 0, 1, 1]
clf = svm.NuSVC()
clf.fit(X, y)
print(clf.predict([[1, 1]]))

LinearSVC（Linear Support Vector Classification）：这个没有关键词kernel,其实也类似于SVC。
与SVC的不同：

• LinearSVC最小化squared hinge loss，而SVC最小化hinge loss
• LinearSVC是基于liblinear实现的，会惩罚截距(penalize the intercept), SVC是基于libsvm实现的，不会惩罚截距。
• liblinear库针对线性的模型进行了优化，因此在大量的数据上收敛速度会高于libsvm。
• LinearSVC使用 （One-vs-All）方式来实现多分类问题，但SVC使用的是One-vs-One的方式来处理多分类的问题。

'''
LinearSVC 参数解释
C：目标函数的惩罚系数C，用来平衡分类间隔margin和错分样本的，default C = 1.0；
loss ：指定损失函数
penalty ：
dual ：选择算法来解决对偶或原始优化问题。当n_samples > n_features 时dual=false。
tol ：（default = 1e - 3）: svm结束标准的精度;
multi_class：如果y输出类别包含多类，用来确定多类策略， ovr表示一对多，“crammer_singer”优化所有类别的一个共同的目标
如果选择“crammer_singer”，损失、惩罚和优化将会被被忽略。
fit_intercept ：
intercept_scaling ：
class_weight ：对于每一个类别i设置惩罚系数C = class_weight[i]*C,如果不给出，权重自动调整为 n_samples / (n_classes * np.bincount(y))
verbose：跟多线程有关
'''
from sklearn import svm
from sklearn.datasets import load_iris #鸢尾花出来打工
X, y = load_iris(return_X_y=True)

clf1 = svm.LinearSVC().fit(X, y) #正常的
clf2 = svm.SVC(kernel='linear').fit(X, y) #核函数为linear的核函数
clf3 = svm.LinearSVC(loss='hinge').fit(X, y)
print("LinearSVC",clf1.score(X, y))
print("SVC(kernel='linear')",clf2.score(X, y))
print("LinearSVC(loss='hinge')",clf3.score(X, y))

（2）多分类问题

from sklearn import svm
X = [[0], [1], [2], [3]]
Y = [0, 1, 2, 3]
clf = svm.SVC(gamma='scale', decision_function_shape='ovo')
#ovo就是0分别跟1,2,3  1跟2，3 2跟3 分别进行一对一形成一个分离超平面
clf.fit(X, Y)
dec = clf.decision_function([[1]])#样本到分隔超平面的有符号距离，哪个近就是哪个类别
print(clf.classes_)

（3）回归问题

也分 SVR, NuSVR 和 LinearSVR的类似上面。

from sklearn import svm
X = [[0, 0], [2, 2]]
y = [0.5, 2.5]
clf = svm.SVR()
#ovo就是0分别跟1,2,3  1跟2，3 2跟3 分别进行一对一形成一个分离超平面
clf.fit(X, y)
clf.predict([[1, 1]])

（4）密度估计，异常检测

OneClassSVM简介：比如只有一个类别，我们就训练一个最小的球形(有可能是三维及三维以上)超球面，把数据包起来，没有包起来的就是不属于这个类的。
官方代码：

'''
参数
kernel：核函数（一般用高斯核）
nu：设定训练误差（0， 1]
方法
fit(x)：训练，根据训练样本和上面两个参数探测边界。（注意是无监督哦！）
predict(x)：返回预测值，+1就是正常样本，-1为异常样本。
decision_function(X)：返回各样本点到超平面的函数距离（signed distance）,正的为正常样本，负的为异常样本。

'''
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager
from sklearn import svm
 
xx, yy = np.meshgrid(np.linspace(-5, 5, 500), np.linspace(-5, 5, 500))
# Generate train data
X = 0.3 * np.random.randn(100, 2)
X_train = np.r_[X + 2, X - 2]
# Generate some regular novel observations
X = 0.3 * np.random.randn(20, 2)
X_test = np.r_[X + 2, X - 2]
# Generate some abnormal novel observations
X_outliers = np.random.uniform(low=-4, high=4, size=(20, 2))
 
# fit the model
clf = svm.OneClassSVM(nu=0.1, kernel="rbf", gamma=0.1)
clf.fit(X_train)
y_pred_train = clf.predict(X_train)
y_pred_test = clf.predict(X_test)
y_pred_outliers = clf.predict(X_outliers)
n_error_train = y_pred_train[y_pred_train == -1].size
n_error_test = y_pred_test[y_pred_test == -1].size
n_error_outliers = y_pred_outliers[y_pred_outliers == 1].size
 
# plot the line, the points, and the nearest vectors to the plane
Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
 
plt.title("Novelty Detection")
plt.contourf(xx, yy, Z, levels=np.linspace(Z.min(), 0, 7), cmap=plt.cm.PuBu)  #绘制异常样本的区域
a = plt.contour(xx, yy, Z, levels=[0], linewidths=2, colors='darkred')  #绘制正常样本和异常样本的边界
plt.contourf(xx, yy, Z, levels=[0, Z.max()], colors='palevioletred')   #绘制正常样本的区域
s = 40
b1 = plt.scatter(X_train[:, 0], X_train[:, 1], c='white', s=s, edgecolors='k')
b2 = plt.scatter(X_test[:, 0], X_test[:, 1], c='blueviolet', s=s,
                 edgecolors='k')
c = plt.scatter(X_outliers[:, 0], X_outliers[:, 1], c='gold', s=s,
                edgecolors='k')
plt.axis('tight')
plt.xlim((-5, 5))
plt.ylim((-5, 5))
plt.legend([a.collections[0], b1, b2, c],
           ["learned frontier", "training observations",
            "new regular observations", "new abnormal observations"],
           loc="upper left",
           prop=matplotlib.font_manager.FontProperties(size=11))
plt.xlabel(
    "error train: %d/200 ; errors novel regular: %d/40 ; "
    "errors novel abnormal: %d/40"
    % (n_error_train, n_error_test, n_error_outliers))
plt.show()

结果：

（5）自定义核函数

from sklearn import svm
import numpy as np
X = [[1,1],[2,2],[3,8],[5,9]]
y = [0, 0,1,1]
def my_kernel(X, Y):
    return np.dot(X, np.transpose(Y))
clf = svm.SVC(kernel=my_kernel)
clf.fit(X, y)
answer = clf.predict([[2, 2]])

2.手写算法

肝不动了= =睡觉了，有时间再把手撸代码完成

参考：
[1] sklearn文档
[2] 周志华 王魏 高尉 张利军 《机器学习理论导引》
[3] comeonbady 支持向量机（SVC，NuSVC，LinearSVC）