支持向量机(分类问题公式及python实现)

NOTEBOOK支持向量机(分类问题公式及python实现)

此notebook包括：
1、支持向量机介绍
2、什么是线性可分类支持向量机
3、什么是线性分类支持向量机
4、硬间隔化和软间隔化
5、什么是线性分类支持向量机的对偶形式
6、非线性支持向量机与核函数
7、利用SVM的人脸识别项目

包涵的代码知识点有：分割数据集，PCA降维、网格搜索与交叉验证、混淆矩阵、评估报告模块等
此篇以从简入繁的形式，结合数学公式与python代码、图片生动的解释了什么是支持向量机。与支持向量机的复杂形式。

学习笔记：Python科学手册、统计学习方法
个人网站：lwh1995.top
Github：lwh1995
橙子 2018/11/24

---

1.支持向量机（SVM）简介

SVM是一种二分类模型。他的基本模型是定义在特征空间上的间隔最大的线性分类器，间隔最大使他有别于感知机。
SVM还包括核技巧，使它成为实质上的非线性分类器。
SVM的学习策略就是间隔最大化，可形式化为一个求解凸二次规划，可等价于正则化的合页函数最小化问题

2.线性可分类支持向量机

通过间隔最大化求解分离超平面：
SVM分类决策函数：

import matplotlib.pyplot as plt
import seaborn; seaborn.set()  # 设置图样为seaborn风格
import numpy as np
# 生成简易分类数据，X：sample ， y：target
from sklearn.datasets.samples_generator import make_blobs
X, y = make_blobs(n_samples=50, centers=2,
                  random_state=0, cluster_std=0.60)
plt.figure(figsize=(14,10))
plt.subplot(2,2,1)
plt.title('1.(a)')
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
# 生成3种可能形式
xfit = np.linspace(-1, 3.5)
plt.subplot(2,2,2)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plt.plot([0.6], [2.1], 'x', color='red', markeredgewidth=2, markersize=10)
plt.title('1.(b)')
for m, b in [(1, 0.65), (0.5, 1.6), (-0.2, 2.9)]:
    plt.plot(xfit, m * xfit + b, '-k')
plt.xlim(-1, 3.5);

如1.(b)图，三个不同分割器都能完美分割样本，但对新样本点X，判别结果有所歧义。
1.(b)所示为感知机模型，可有多条直线分割训练集
SVM在感知机模型基础上，引入间隔概念，间隔包含函数间隔与几何间隔。
当我们最大化几何间隔时，分离超平面是唯一确定的。下面介绍硬间隔最大化的线性可分SVM
SVM其实是一个边界最大化评估器

3.硬间隔最大化线性可分支持向量机的最优化问题：

from sklearn.svm import SVC # 导入SVC类 SVC(Support vector classifier)
model = SVC(kernel='linear', C=1E10) # 引入线性核函数
model.fit(X, y)

def plot_svc_decision_function(model, ax=None, plot_support=True):
    """画2维SVC的决策函数（分离超平面）"""
    if ax is None:
        ax = plt.gca() #plt.gca()获得当前的Axes对象ax
    xlim = ax.get_xlim() #Return the x-axis view limits返回x轴视图限制。
    ylim = ax.get_ylim() 
    # 创建评估模型的网格
    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x) # 将两个一维数组变为二维矩阵 返回一个行乘和列乘的二维数组
    xy = np.vstack([X.ravel(), Y.ravel()]).T # np.vstack()沿着竖直方向将矩阵堆叠起来。 
    P = model.decision_function(xy).reshape(X.shape)   
    # 画决策边界和边界
    ax.contour(X, Y, P, colors='k',
               levels=[-1, 0, 1], alpha=0.5,
               linestyles=['--', '-', '--'])
    # 画支持向量
    if plot_support:
        ax.scatter(model.support_vectors_[:, 0],
                   model.support_vectors_[:, 1],
                   s=200, linewidth=1,c='k',alpha=0.4)
    ax.set_xlim(xlim)
    ax.set_ylim(ylim)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(model)

上图中用黑圈表示的点是拟合的关键点，被称为支持向量，支持向量坐标存放在.support_vectors_属性中

4.线性可分支持向量机的对偶形式

然后和感知机一样，线性支持向量机存在对偶形式（引入拉格朗日乘子向量）
原始问题的对偶问题是极大极小问题：先求极小再求极大，求偏导，利用随机梯度下降法优化参数

# 画出数据集前60个点和前120个点的拟合结果对比
def plot_svm(N=10, ax=None):
    X, y = make_blobs(n_samples=200, centers=2,
                      random_state=0, cluster_std=0.60)
    X = X[:N]
    y = y[:N]
    model = SVC(kernel='linear', C=1E10)
    model.fit(X, y)
    
    ax = ax or plt.gca()
    ax.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
    ax.set_xlim(-1, 4)
    ax.set_ylim(-1, 6)
    plot_svc_decision_function(model, ax)

fig, ax = plt.subplots(1, 2, figsize=(16, 6))
fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)
for axi, N in zip(ax, [60, 120]):
    plot_svm(N, axi)
    axi.set_title('N = {0}'.format(N))

从上方左图可以看到的是前60个训练样本的模型和支持向量。在右图中虽然我们画了前120个训练样本的支持向量。
但是模型并没有改变，这种对原理边界的数据点不敏感的特点正是SVM模型的优点之一。

5.线性支持向量机与软间隔最大化

线性不可分意味着某些样本点不能满足函数间隔大于1的约束条件。
为了解决这一问题，引入松弛变量　　，使函数间隔加上松弛变量大于等于1。约束条件为：
目标函数为： 其中为惩罚参数，C值大时对误分类惩罚增大，反之亦然，为调和系数。
有了软间隔最大化的定义，就可以处理线性不可分的线性支持向量机，学习问题变成凸二次规划问题。

# 使用make_blobs生成有重叠的数据
X, y = make_blobs(n_samples=100, centers=2,
                  random_state=0, cluster_std=1.2)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')

# 定义画板
fig, ax = plt.subplots(1, 2, figsize=(16, 6))
fig.subplots_adjust(left=0.0625, right=0.95, wspace=0.1)
# C为10.0和0.1时软间隔最大化的线性支持向量机
for axi, C in zip(ax, [10.0, 0.1]): # zip()方法:打包为元组的列表
    model = SVC(kernel='linear', C=C).fit(X, y)
    axi.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
    plot_svc_decision_function(model, axi)
    axi.scatter(model.support_vectors_[:, 0],
                model.support_vetors_[:, 1],
                s=300, lw=1, facecolors='none');
    axi.set_title('C = {0:.1f}'.format(C), size=14)

如上程序块所示，SVC()模型中的C就是惩罚参数，来软化边界。
边界线的硬度通过C来控制，C很大时，边界很硬；C比较小时，边界较软，有一些数据点就可以穿越边界线。
接下来，我们使用网格搜索法来寻找最优C的数值，并作图。

from sklearn.grid_search import GridSearchCV # 网格搜索法
param_grid = {'C':[1,2,3,4,5,6,7,8,9,10]}
grid = GridSearchCV(model, param_grid, cv=7)
grid.fit(X, y)
print(grid.best_params_)

output:{'C': 2}

model = SVC(kernel='linear', C=2).fit(X, y)
plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(model)
plt.scatter(model.support_vectors_[:, 0],
            model.support_vectors_[:, 1],
            s=300, lw=1, facecolors='none')
plt.title('C = {0:.1f}'.format(2), size=14)
plt.show()

6.非线性支持向量机与核函数

# 为了应用核函数，引入一些非线性可分的数据
from sklearn.datasets.samples_generator import make_circles
X, y = make_circles(100, factor=.1, noise=.1)

clf = SVC(kernel='linear').fit(X, y)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(clf, plot_support=False)

如上图，2维数据就不能被线性分割，如果能用多维的一个超平面将正负例正确分开，则称这个问题为非线性可分问题。

非线性问题不好求解，所采取的方法是进行一个非线性变换，将非线性问题变换为线性问题。
核技巧的基本想法为：通过一个非线性变换将输入空间对应于一个特征空间，使得在输入空间中的超曲面模型对应于特征空间中的超平面模型（支持向量机）
简明的说就是将对偶问题的目标函数中的内积，转化为非线性的核函数（内积）。具体公式见统计学习方法。
核函数为：,　　为映射函数
核技巧的想法是：在学习与预测中只定义核函数，而不显示地定义映射函数。

此时，带核函数的非线性SVM的目标函数为：分类决策函数式为：

核函数的充要条件为正定核，就是K关于X的Gram矩阵是半正定的。
常用核函数：多项式核函数、高斯核函数、字符串核函数

r = np.exp(-(X ** 2).sum(1))
from mpl_toolkits import mplot3d
def plot_3D(elev=30, azim=30, X=X, y=y):
    ax = plt.subplot(projection='3d')
    ax.scatter3D(X[:, 0], X[:, 1], r, c=y, s=50, cmap='autumn')
    ax.view_init(elev=elev, azim=azim)
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.set_zlabel('r')

interact(plot_3D, elev=[-90, 90], azip=(-180, 180),
         X=fixed(X), y=fixed(y));

使用基函数做核函数：计算基函数在数据集上每个点的变换结果，让SVM算法从所有结果中筛选出最优解。
将线性核转变为RBF（径向基函数）核，设置kernel模型超参数即可。

clf = SVC(kernel='rbf', C=1E6)
clf.fit(X, y)

Out:SVC(C=1000000.0, cache_size=200, class_weight=None, coef0=0.0,
decision_function_shape='ovr', degree=3, gamma='auto', kernel='rbf',
max_iter=-1, probability=False, random_state=None, shrinking=True,
tol=0.001, verbose=False)

plt.scatter(X[:, 0], X[:, 1], c=y, s=50, cmap='autumn')
plot_svc_decision_function(clf)
plt.scatter(clf.support_vectors_[:, 0], clf.support_vectors_[:, 1],
            s=300, lw=1, facecolors='none');

7.案例：人脸识别（SVC，分类问题）

使用Wild数据集，首先导入数据集，查看需要处理的数据

# 导入数据集
from sklearn.datasets import fetch_lfw_people
faces = fetch_lfw_people(min_faces_per_person=60)
print(faces.target_names)
print(faces.images.shape)

# 使用ax来定位3行5列画布
fig, ax = plt.subplots(3, 5)
for i, axi in enumerate(ax.flat):
    axi.imshow(faces.images[i], cmap='bone')
    axi.set(xticks=[], yticks=[],
            xlabel=faces.target_names[faces.target[i]])

Out:['Ariel Sharon' 'Colin Powell' 'Donald Rumsfeld' 'George W Bush'
'Gerhard Schroeder' 'Hugo Chavez' 'Junichiro Koizumi' 'Tony Blair']
(1348, 62, 47)

每个图像包含(62×47)或近3000像素。有1348张人脸图
3千个特征过多，一般使用预处理器来提取更有意义的特征（采用PCA主成成分分析法）提取150个基本元素
然后将它提供给SVC。下面是将预处理器和分类器打包成管道的代码：

from sklearn.svm import SVC
from sklearn.decomposition import RandomizedPCA
from sklearn.pipeline import make_pipeline

pca = RandomizedPCA(n_components=150, whiten=True, random_state=42) # n_components=150
svc = SVC(kernel='rbf', class_weight='balanced') # kernel='rbf'
model = make_pipeline(pca, svc) # 打包管道

为了测试分类器的训练效果，将数据集分解成训练集和测试集进行交叉检验。

from sklearn.cross_validation import train_test_split
Xtrain, Xtest, ytrain, ytest = train_test_split(faces.data, faces.target,
                                                random_state=42)

然后用网格搜索交叉检验来寻找最优参数组合。通过不断调整参数C，和参数gamma（控制径向基函数核的大小），确定最优模型

from sklearn.grid_search import GridSearchCV
import warnings 
warnings.filterwarnings('ignore')

param_grid = {'svc__C': [1, 5, 10, 50],
              'svc__gamma': [0.0001, 0.0005, 0.001, 0.005]}
grid = GridSearchCV(model, param_grid)

%time grid.fit(Xtrain, ytrain)
print(grid.best_params_)

Out:Wall time: 11.7 s
{'svc__C': 5, 'svc__gamma': 0.001}
最优参数落在了网格的中间位置。如果落在边缘位置，我们还需继续拓展网格搜索范围。
接下来，我们可以对测试集的数据进行预测了：

model = grid.best_estimator_
yfit = model.predict(Xtest)

from sklearn.metrics import accuracy_score #准确率得分
print('人脸识别分类准确率：',accuracy_score(ytest, yfit))

人脸识别分类准确率： 0.848664688427

可以看出SVC经过PCA从3000+维度降到150维，分割数据集，然后使用网格搜索和交叉验证寻找网络最优参数的方法
使得人脸识别率达到了84%。
下面将一些测试图片和预测图片进行对比：

fig, ax = plt.subplots(4, 6)
for i, axi in enumerate(ax.flat):
    axi.imshow(Xtest[i].reshape(62, 47), cmap='bone')
    axi.set(xticks=[], yticks=[])
    axi.set_ylabel(faces.target_names[yfit[i]].split()[-1],
                   color='black' if yfit[i] == ytest[i] else 'red')
fig.suptitle('Predicted Names; Incorrect Labels in Red', size=14);

下面我们打印分类效果报告，列举每个标签的统计结果，从而对评估器的性能有更全面的了解：

from sklearn.metrics import classification_report # 分类效果报告模块
print(classification_report(ytest, yfit,
                            target_names=faces.target_names))

画出人脸数据混淆矩阵

import seaborn as sns
from sklearn.metrics import confusion_matrix
mat = confusion_matrix(ytest, yfit)
sns.heatmap(mat.T, square=True, annot=True, fmt='d', cbar=False,
            xticklabels=faces.target_names,
            yticklabels=faces.target_names)
plt.xlabel('true label')
plt.ylabel('predicted label');

混淆矩阵可以清晰的判断哪些标签容易被分类器误判。
真实环境中的人脸识别问题的照片通常不会被切割得这么整齐，两类人脸分类机制的唯一差别在于：
你需要使用更复杂的算法找到人脸（定位问题），然后提取图片中与像素化无关的人脸特征（OpenCV可以解决）。