’决策树’，‘Logistic回归’，'支持向量机’

一、决策树方法的基本原理；

决策树是一种基本的回归与分类方法；可以认为是if-then规则的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。其优点是模型具备可读性，分类速度快；

决策树模型：

定义：
分类决策树模型是一种描述对实例进行分类的树状结构。决策树由节点和有向边组成。节点有两种类型：内部节点和叶节点。内部节点表示一个特征或属性，叶节点表示一个类；

将决策树转换成if-then规则:

由决策树的根节点到叶节点的每一条路径构建一条规则；路径上内部节点的特征对应着规则的条件，而叶节点的类对应着规则的结论。决策树的路径或者其对应的if-then规则集合具有一个重要的性质：互斥且完备；

决策树学习：

决策树学习的目标是根据给定的训练数据集构建一个决策树模型，使它能够对实例进行正确的分类。决策树学习本质上是从训练数据集中归纳出一组分类规则。与训练数据集不想矛盾的决策树，同时具有很好的泛化能力。换句话说，决策树学习是由训练数据集估计条件概率模型。

决策树学习用损失函数表示这一目标，决策树学习的存实函数通常是正则化的最大似然函数。决策树学习的策略就是一损失函数为目标函数的函数最小化；

因为所有可能的决策树中选取最优的决策树是np完全问题，所以现实中决策树学习算法通常采用启发式方法，近似求解这一最优化问题；

决策树学习算法通常是一个递归的选择最优特征，并根据该特征对训练数据进行分割，使得各个子数据集有一个最好的分类过程；这样对于训练数据集常常会有很好的效果，但存在出现过拟合的问题；因此需要对已生成的树自下而上的剪枝。

综上所述，决策树学习算法包含特征选择、决策树生成、决策树剪枝；决策树生成对应于模型的局部选择，决策树剪枝对应于模型的全局选择。常用算法有ID3、C4.5、CART。

特征选择：

如果利用一个特征进行分类的结果与随机分类结果差别不大，则称这个特征是没有分类能力的。通常特征选择的准则是信息增益或信息增益比；

信息增益：

信息论与概率统计中，熵是表示随机变量不确定性的度量。

设 X X X是一个取有限个值的离散随机变量，其概率分布为

P ( X = x i ) = p i , i = 1 , 2 , ⋯ , n P\left( X = x_{i} \right) = p_{i}\ ,i = 1,2,\cdots,n P(X=xi)=pi ,i=1,2,⋯,n

其随机变量 X X X的熵定义为

H ( X ) = − ∑ i = 1 n p i log ⁡ p i H\left( X \right) = - \sum_{i = 1}^{n}{p_{i}\log p_{i}} H(X)=−i=1∑npilogpi

设随机变量 ( X , Y ) (X,Y) (X,Y)，其联合概率分布为

P ( X = x i , Y = y i ) = p i j , i = 1 , 2 , ⋯ , n ; j = 1 , 2 , ⋯ , m P\left( X = x_{i},Y = y_{i} \right) = p_{ij}\ ,i = 1,2,\cdots,n;j = 1,2,\cdots,m P(X=xi,Y=yi)=pij ,i=1,2,⋯,n;j=1,2,⋯,m

随机变量 X X X给定条件下随机变量 Y Y Y的条件熵 H ( Y ∣ X ) H(Y|X) H(Y∣X),定义为 X X X给定条件下 Y Y Y的条件概率分布的熵对 X X X的数学期望

H ( Y ∣ X ) = ∑ i = 1 n p i H ( Y ∣ X = x i ) H\left( Y|X \right) = \sum_{i = 1}^{n}{p_{i}H(Y|X = x_{i})} H(Y∣X)=i=1∑npiH(Y∣X=xi)

当熵和条件熵中的概率由数据估计（尤其极大似然估计）的到时，所对应的熵和条件熵分别成为经验熵和经验条件熵,且令 0 l o g 0 = 0 0log0 = 0 0log0=0。

信息增益表示得知特征 X X X的信息而使得类 Y Y Y的信息的不确定性减少程度。

g ( D , A ) = H ( D ) − H ( D ∣ A ) g\left( D,A \right) = H\left( D \right) - H(D|A) g(D,A)=H(D)−H(D∣A)

通常对训练数据集D，计算其每个特征的增益信息，并比较它们的大小，选择信息增益最大的特征；

信息增益比:

以信息增益作为划分训练数据集的特征，存在偏向于选择取值较多的特征的问题，使用信息增益比可以校正这一问题；

决策树的生成：

ID3算法：

从根节点开始，对节点计算所有可能的特征的信息增益，选择信息增益最大的特征作为节点的特征，由该特征的不同取值建立子节点；再对子节点递归的调用以上方法，构建决策树；直到所有特征的信息增益均很小或没有特征可以选择为止。最后得到一棵决策树。ID3相当于用极大似然法进行概率模型的选择；

C4.5的生成算法：

C4.5算法与ID3算法类似，C4.5算法对ID3算法进行了改进。C4.5在生成的过程中，用信息增益比来选择特征；

决策树的剪枝：

决策树的剪枝往往通过极小化决策树整体的损失函数或代价函数来实现。设树 T T T的叶节点个数为 ∣ T ∣ |T| ∣T∣, t t t是树 T T T的叶节点，该叶节点有 N i N_{i} Ni个样本点，其中 k k k类样本点有 N tk N_{\text{tk}} Ntk个， k = 1 , 2 , ⋯ k k = 1,2,\cdots k k=1,2,⋯k, H t ( T ) H_{t}(T) Ht(T)为叶节点 t t t上的经验熵， a ≥ 0 a \geq 0 a≥0为参数，则决策树学习的损失函数可以定义为

C a ( T ) = ∑ t = 1 ∣ T ∣ N t H t ( T ) + α ∣ T ∣ ( 1 ) C_{a}\left( T \right) = \sum_{t = 1}^{|T|}{N_{t}H_{t}(T)} + \alpha\left| T \right|\ \ (1) Ca(T)=t=1∑∣T∣NtHt(T)+α∣T∣ (1)

其中经验熵为

H t ( T ) = − ∑ k N tk N k log ⁡ N tk N k ( 2 ) H_{t}\left( T \right) = - \sum_{k}^{}{\frac{N_{\text{tk}}}{N_{k}}\log\frac{N_{\text{tk}}}{N_{k}}}\ \ \ (2) Ht(T)=−k∑NkNtklogNkNtk (2)

将式（1）右端的第一项记作

C ( T ) = ∑ t = 1 ∣ T ∣ N t H t ( T ) = − ∑ t = 1 ∣ T ∣ ∑ k = 1 k N tk log ⁡ N tk N k C\left( T \right) = \ \sum_{t = 1}^{|T|}{N_{t}H_{t}(T)} = - \sum_{t = 1}^{|T|}{\sum_{k = 1}^{k}{N_{\text{tk}}\log\frac{N_{\text{tk}}}{N_{k}}}} C(T)= t=1∑∣T∣NtHt(T)=−t=1∑∣T∣k=1∑kNtklogNkNtk

则有

C a ( T ) = C ( T ) + α ∣ T ∣ C_{a}\left( T \right) = C\left( T \right) + \ \alpha\left| T \right| Ca(T)=C(T)+ α∣T∣

其中 α ≥ 0 \alpha \geq 0 α≥0控制 C ( T ) C\left( T \right) C(T)（训练模型的误差预测）和 ∣ T ∣ \left| T \right| ∣T∣（模型的复杂程度）两者之间的影响；

CART算法（分类回归树算法）：

CART生成：

回归树：

一颗回归树对应输入空间的划分以及在划分单元上的输出值。其可以用平方误差来衡量回归树的预测误差；对于如何对特征空间划分，这里采用启发式方法，选择第 j j j个变量 x ( j ) x^{(j)} x(j)和他的取值 s s s,作为切分变量和切分点，随后寻找最优切分变量，切分点

min ⁡ j , s [ min ⁡ c 1 ∑ x i ∈ R 2 ( j , s ) ( y i − c 1 ) 2 + min ⁡ c 2 ∑ x i ∈ R 2 ( j , s ) ( y i − c 2 ) 2 ] \min_{j,s}\left\lbrack \min_{c1}{\sum_{x_{i} \in R_{2}(j,s)}^{}\left( y_{i} - c_{1} \right)^{2} + \min_{c2}{\sum_{x_{i} \in R_{2}(j,s)}^{}\left( y_{i} - c_{2} \right)^{2}}} \right\rbrack j,smin⎣⎡c1minxi∈R2(j,s)∑(yi−c1)2+c2minxi∈R2(j,s)∑(yi−c2)2⎦⎤

固定输入变量 j j j找到最优切分点 s s s，便利所有变量找出最优切分变量构成一对 ( j , s ) (j,s) (j,s),将输入空间进行划分；重复上述过程到满足停止条件；如此得

最小二乘回归树；

分类树：

分类树用基尼指数选择最优特征，同时决定特征的最优二值切分点；在分类问题中假设有 k k k个类，样本点属于 k k k的概率为 p k p_{k} pk,则概率分布的基尼指数

Gini ( p ) = ∑ k = 1 k p k ( 1 − p k ) = 1 − ∑ k = 1 k p k 2 \text{Gini}\left( p \right) = \ \sum_{k = 1}^{k}{p_{k}\left( 1 - p_{k} \right)} = 1 - \sum_{k = 1}^{k}p_{k}^{2} Gini(p)= k=1∑kpk(1−pk)=1−k=1∑kpk2

对于给定的样本集合 D D D，其基尼指数为

Gini ( p ) = 1 − ∑ k = 1 k ( ∣ C k ∣ ∣ D ∣ ) 2 \text{Gini}\left( p \right) = 1 - \sum_{k = 1}^{k}\left( \frac{\left| C_{k} \right|}{\left| D \right|} \right)^{2} Gini(p)=1−k=1∑k(∣D∣∣Ck∣)2

特征 A A A条件下集合 D D D的基尼指数

Gini ( D , A ) = ∣ D 1 ∣ ∣ D ∣ Gini ( D 1 ) + ∣ D 2 ∣ ∣ D ∣ Gini ( D 2 ) \text{Gini}\left( D,A \right) = \frac{\left| D_{1} \right|}{\left| D \right|}\text{Gini}\left( D_{1} \right) + \frac{\left| D_{2} \right|}{\left| D \right|}\text{Gini}\left( D_{2} \right) Gini(D,A)=∣D∣∣D1∣Gini(D1)+∣D∣∣D2∣Gini(D2)

基尼指数 Gini ( D ) \text{Gini}(D) Gini(D)表示 D D D的不确定性，基尼指数 Gini ( D , A ) \text{Gini}(D,A) Gini(D,A)表示经过 A = a A = a A=a划分后集合 D D D的不确定性；

CART生成算法与ID3和C4.5类似，只是将每次迭代时候需要遍历特征及可能值，选择基尼指数最小的作为最优特征与最优切分点；

CART剪枝：

子树的损失函数为：

C a ( T ) = C ( T ) + α ∣ T ∣ C_{a}\left( T \right) = C(T) + \alpha\left| T \right| Ca(T)=C(T)+α∣T∣

对固定的 α \alpha α，一定存在损失函数 C a ( T ) C_{a}\left( T \right) Ca(T)最小的子树，这样的最优子树是唯一的；当 α \alpha α大的时候，最有子树 T a T_{a} Ta偏小，反之，子树偏大；当 α \alpha α增大时只要 α = C ( t ) − C ( T t ) ∣ T t ∣ − 1 \alpha = \frac{C\left( t \right) - C(T_{t})}{\left| T_{t} \right| - 1} α=∣Tt∣−1C(t)−C(Tt)
t相对来说节点少，损失函数值相同，因此需要进行剪枝；

为此，对 T 0 T_{0} T0遍历计算每一个内部节点 t t t，计算

g ( t ) = C ( t ) − C ( T t ) ∣ T t ∣ − 1 g(t) = \frac{C\left( t \right) - C(T_{t})}{\left| T_{t} \right| - 1} g(t)=∣Tt∣−1C(t)−C(Tt)

在 T 0 T_{0} T0中减去 g ( t ) g(t) g(t)最小的 T t T_{t} Tt,将得到的子树作为 T 1 T_{1} T1,同时将最小的 g ( t ) g(t_{\ }) g(t )设为 α 1 \alpha_{1} α1. T 1 T_{1} T1为区间 [ α 1 , α 2 ) \left\lbrack \left. \ \alpha_{1},\alpha_{2} \right) \right.\ [ α1,α2) 最优子树。如此进行不断地迭代，直至根节点，这一过程中* α t \alpha_{t} αt的值不断增加，产生新的区间；

最终将得到的子树序列 T 0 , T 1 , ⋯ , T n \mathbf{T}_{\mathbf{0}}\mathbf{,}\mathbf{T}_{\mathbf{1}}\mathbf{,\cdots,}\mathbf{T}_{\mathbf{n}} T0,T1,⋯,Tn通过交叉验证选取最优子树；具体可以利用独立验证书记，测试子树序列的平方误差或基尼指数。同时当 T k \mathbf{T}_{\mathbf{k}} Tk确定之后也会确定对应的 α k \alpha_{k} αk

二、Logistic回归的基本原理；

二项 Logistic \text{Logistic} Logistic回归模型是一种分类模型，由条件概率分布 P ( Y ∣ X ) P(Y|X) P(Y∣X)表示，形式为参数化的 Logistic \text{Logistic} Logistic分布。这里，随机变量 X X X取值为实数，随机变量 Y Y Y的取值为1或0.我们通过监督学习的方法估计参数模型；其定义是如下的条件概率分布：

P ( Y = 1 | X ) = e x p ( w ⋅ x + b ) 1 + e x p ( w ⋅ x + b ) P\left( Y = 1 \middle| X \right) = \frac{exp(w \cdot x + b)}{1 + exp(w \cdot x + b)} P(Y=1∣X)=1+exp(w⋅x+b)exp(w⋅x+b)

P ( Y = 0 | X ) = 1 1 + e x p ( w ⋅ x + b ) P\left( Y = 0 \middle| X \right) = \frac{1}{1 + exp(w \cdot x + b)} P(Y=0∣X)=1+exp(w⋅x+b)1

有些时候为了方便将权值向量和输入空间进行扩充，这时 Logistic \text{Logistic} Logistic模型如下

P ( Y = 1 | X ) = e x p ( w ⋅ x ) 1 + e x p ( w ⋅ x ) P\left( Y = 1 \middle| X \right) = \frac{exp(w \cdot x)}{1 + exp(w \cdot x)} P(Y=1∣X)=1+exp(w⋅x)exp(w⋅x)

P ( Y = 0 | X ) = 1 1 + e x p ( w ⋅ x ) P\left( Y = 0 \middle| X \right) = \frac{1}{1 + exp(w \cdot x)} P(Y=0∣X)=1+exp(w⋅x)1

定义对数几率或 logit \text{logit} logit函数是

logit ( p ) = log ⁡ p 1 − p \text{logit}\left( p \right) = \log\frac{p}{1 - p} logit(p)=log1−pp

对 Logistic \text{Logistic} Logistic回归模型而言

log ⁡ p ( Y = 1 ∣ x ) 1 − p ( Y = 1 ∣ x ) = w ⋅ x \log\frac{p(Y = 1|x)}{1 - p(Y = 1|x)} = w \cdot x log1−p(Y=1∣x)p(Y=1∣x)=w⋅x

也就是，在 Logistic \text{Logistic} Logistic回归模型中，输出 Y = 1 Y = 1 Y=1的对数几率是输入 x x x的线性函数。也就是说 Y = 1 Y = 1 Y=1对数几率是由输入 x x x的线性函数表示的模型，即也就是 logistic \text{logistic} logistic回归模型。

从另一个角度通过 logistic \text{logistic} logistic模型定义式可以将线性函数 w ⋅ x w \cdot x w⋅x转换为概率：

P ( y = 1 | x ) = e x p ( w ⋅ x ) 1 + e x p ( w ⋅ x ) P\left( y = 1 \middle| x \right) = \frac{exp(w \cdot x)}{1 + exp(w \cdot x)} P(y=1∣x)=1+exp(w⋅x)exp(w⋅x)

此时线性函数越接近于正无穷，概率就越接近1。线性函数越接近于负无穷，概率值接近于0。这样的模型就是 logistic \text{logistic} logistic回归模型。

模型参数估计：

在 logistic \text{logistic} logistic回归模型学习时，对于给定的训练数据集 T T T,可以应用极大似然估计法估计参数模型

设：

P ( Y = 1 | x ) = Π ( x ) , P ( Y = 0 | x ) = 1 − Π ( x ) P\left( Y = 1 \middle| x \right) = \Pi\left( x \right),P\left( Y = 0 \middle| x \right) = 1 - \Pi\left( x \right) P(Y=1∣x)=Π(x),P(Y=0∣x)=1−Π(x)

似然函数为

∏ i = 1 n [ Π ( x i ) ] y i [ 1 − Π ( x i ) ] 1 − y i \prod_{i = 1}^{n}{\left\lbrack \Pi\left( x_{i} \right) \right\rbrack^{y_{i}}\left\lbrack 1 - \Pi\left( x_{i} \right) \right\rbrack^{1 - y_{i}}} i=1∏n[Π(xi)]yi[1−Π(xi)]1−yi

对数似然函数为

L ( w ) = ∑ i = 1 n [ y i log ⁡ Π ( x i ) + ( 1 − y i ) log ⁡ ( 1 − Π ( x i ) ) ] L\left( w \right) = \sum_{i = 1}^{n}\left\lbrack y_{i}\log{\Pi\left( x_{i} \right)} + \left( 1 - y_{i} \right)\log\left( 1 - \Pi\left( x_{i} \right) \right) \right\rbrack L(w)=i=1∑n[yilogΠ(xi)+(1−yi)log(1−Π(xi))]

= ∑ i = 1 n [ y i ( w ⋅ x i ) + log ⁡ ( 1 + e x p ( w ⋅ x i ) ) ] = \sum_{i = 1}^{n}\left\lbrack y_{i}\left( w \cdot x_{i} \right) + \log\left( 1 + exp(w \cdot x_{i}) \right) \right\rbrack =i=1∑n[yi(w⋅xi)+log(1+exp(w⋅xi))]

对 L ( w ) L(w) L(w)求极大值，得到 w w w的估计值。这样问题就转换成了对对数似然函数为目标函数的优化问题。 logistic \text{logistic} logistic回归学习中通常采用梯度下降法及拟牛顿法；

对于多项 logistic \text{logistic} logistic回归模型，其可以表示为:

P ( Y = k | X ) = e x p ( w k ⋅ x ) 1 + ∑ k = 1 K − 1 e x p ( w k ⋅ x ) , k = 1 , 2 , ⋯ , K − 1 P\left( Y = k \middle| X \right) = \frac{exp(w_{k} \cdot x)}{1 + \sum_{k = 1}^{K - 1}{exp(w_{k} \cdot x)}}\ ,\ \ \ k = 1,2,\cdots,K - 1 P(Y=k∣X)=1+∑k=1K−1exp(wk⋅x)exp(wk⋅x) , k=1,2,⋯,K−1

P ( Y = K | X ) = 1 1 + ∑ k = 1 K − 1 e x p ( w k ⋅ x ) P\left( Y = K \middle| X \right) = \frac{1}{1 + \sum_{k = 1}^{K - 1}{exp(w_{k} \cdot x)}}\ P(Y=K∣X)=1+∑k=1K−1exp(wk⋅x)1

二项的参数估计法也可以推广到多项 logistic \text{logistic} logistic回归中；

三、线性支持向量机与非线性支持向量机原理的区别与联系；

支持向量机：

支持向量机（SVM）是一种二分类的分类模型。它的基本模型是定义在特征空间上的见间隔最大的线性分类器，间隔使之区别于感知机；其中还包括核技巧，这使之成为实质上的非线性分类器；支持向量机的学习方法由简到繁分为线性可分支持向量机、线性支持向量机及非线性支持向量机；其中非线性支持向量机中的核方法（kernel method）是比支持向量机更为一般的机器学习方法；

线性支持向量机：

给定线性可分的训练数据集，通过间隔最大化或等价的求解相应的凸二次和规划问题学习得到的分离超平面为

w ∗ ⋅ x + b ∗ = 0 w^{*} \cdot x + b^{*} = 0 w∗⋅x+b∗=0

相应的分类决策函数为

f ( x ) = s i g n ( w ∗ ⋅ x + b ∗ ) f\left( x \right) = sign(w^{*} \cdot x + b^{*}) f(x)=sign(w∗⋅x+b∗)

最大间隔法：

函数间隔： r ^ = min ⁡ i = 1 , 2 , ⋯ , N ( y i ( w ⋅ x i + b ) ) \widehat{r} = \min_{i = 1,2,\cdots,N}{(y_{i}(w \cdot x_{i} + b))} r =mini=1,2,⋯,N(yi(w⋅xi+b))

由于成比例的变换 w , b w,b w,b,会导致函数间隔变化，进一步引出几何间隔：

r ^ = min ⁡ i = 1 , 2 , ⋯ , N ( y i ( w ∥ w ∥ ⋅ x i + b ∥ w ∥ ) ) \widehat{r} = \min_{i = 1,2,\cdots,N}\left( y_{i}\left( \frac{w}{\left\| w \right\|} \cdot x_{i} + \frac{b}{\left\| w \right\|} \right) \right) r =i=1,2,⋯,Nmin(yi(∥w∥w⋅xi+∥w∥b))

于是转化为：

max ⁡ w , b γ {\ \max_{w,b}}\gamma w,bmaxγ

s.t. y i ( w ∥ w ∥ ⋅ x i + b ∥ w ∥ ) ≥ γ , i = 1 , 2 , ⋯ , N \text{s.t.\ \ }y_{i}\left( \frac{w}{\left\| w \right\|} \cdot x_{i} + \frac{b}{\left\| w \right\|} \right) \geq \ \gamma,i = 1,2,\cdots,N s.t. yi(∥w∥w⋅xi+∥w∥b)≥ γ,i=1,2,⋯,N

等价转化为：

min ⁡ w , b 1 2 ∥ w ∥ 2 {\ \min_{w,b}}{\frac{1}{2}\left\| w \right\|^{2}} w,bmin21∥w∥2

s.t. y i ( w ⋅ x i + b ) − 1 ≥ 0 , i = 1 , 2 , ⋯ , N \text{s.t.\ \ \ \ }y_{i}\left( w \cdot x_{i} + b \right) - 1 \geq \ 0,i = 1,2,\cdots,N s.t. yi(w⋅xi+b)−1≥ 0,i=1,2,⋯,N

最大间隔分离超平面具备存在唯一性（证明略）

对 y i = + 1 y_{i} = + 1 yi=+1的正例点，支持向量在超平面

H 1 : w ⋅ x + b = 1 H_{1}:w \cdot x_{\ } + b = 1 H1:w⋅x +b=1

y i = − 1 y_{i} = - 1 yi=−1的正例点，支持向量在超平面

H 2 : w ⋅ x + b = − 1 H_{2}:w \cdot x_{\ } + b = - 1 H2:w⋅x +b=−1

如此在 H 1 , H 2 H_{1},H_{2} H1,H2上的点就是支持向量。 H 1 , H 2 H_{1},H_{2} H1,H2平行，且两者之间没有实例点。在决定分离超平面时只有支持向量起作用，而其他实例点不起作用，因为支持向量的个数一般很少，所以支持向量机由很少"重要的"训练样本去确定；

为了求解支持向量机的最优化问题，将它作为原始优化应用拉格朗日对偶性，通过求解对偶问题求出最优解；定义拉格朗日函数：

L ( w , b , α ) = 1 2 ∥ w ∥ 2 − ∑ i = 1 N a i y i ( w ⋅ x i + b ) + ∑ i = 1 N a i L\left( w,b,\alpha \right) = \frac{1}{2}\left\| w \right\|^{2} - \sum_{i = 1}^{N}{a_{i}y_{i}\left( w \cdot x_{i} + b \right)} + \sum_{i = 1}^{N}a_{i} L(w,b,α)=21∥w∥2−i=1∑Naiyi(w⋅xi+b)+i=1∑Nai

最终假设 α \mathbf{\alpha} α的解为 α ∗ \mathbf{\alpha}^{\mathbf{*}} α∗，对 w , b \mathbf{w}\mathbf{,b} w,b的解有 w ∗ , b ∗ \mathbf{w}^{\mathbf{*}}\mathbf{,}\mathbf{b}^{\mathbf{*}} w∗,b∗于是有解

w ∗ = ∑ i = 1 N a i ∗ y i x i w^{*} = \sum_{i = 1}^{N}{{a_{i}}^{*}y_{i}x_{i}} w∗=i=1∑Nai∗yixi

b ∗ = y j − ∑ i = 1 N a i ∗ y i ( x i , x j ) b^{*} = y_{j} - \sum_{i = 1}^{N}{{a_{i}}^{*}y_{i}(x_{i},x_{j})} b∗=yj−i=1∑Nai∗yi(xi,xj)

支持向量为

w ∗ ⋅ x i + b ∗ = ± 1 w^{*} \cdot x_{i} + b^{*} = \ \pm 1 w∗⋅xi+b∗= ±1

然而这样的学习方法对于线性不可分的数据是不适用的，因此我们引入引进一个松弛变量 ε i \mathbf{\varepsilon}_{\mathbf{i}} εi***，于是约束条件变为***

y i ( w ⋅ x i + b ) ≥ 1 − ε i y_{i}\left( w \cdot x_{i} + b \right) \geq \ 1 - \varepsilon_{i} yi(w⋅xi+b)≥ 1−εi

目标函数变成了

1 2 ∥ w ∥ 2 + C ∑ i = 1 N ε i \frac{1}{2}\left\| w \right\|^{2}\mathbf{+}C\sum_{i = 1}^{N}\varepsilon_{i} 21∥w∥2+Ci=1∑Nεi

于是最终在最优解 a ∗ a^{\mathbf{*}} a∗的选择上 a i a_{i} ai的约束条件从 a i ≥ 0 a_{i} \geq 0 ai≥0变成了 c ≥ a i ≥ 0 c\mathbf{\geq}a_{i} \geq 0 c≥ai≥0;
其他的与上述的线性可分支持向量机的算法相同；

另外线性支持向量机学习还有另外一种解释，就是最小化以下目标函数：

∑ i = 1 N [ 1 − y i ( w ⋅ x i + b ) ] + + λ ∥ w ∥ 2 \sum_{i = 1}^{N}{\left\lbrack 1 - y_{i}\left( w \cdot x_{i} + b \right) \right\rbrack_{+} + \lambda\left\| w \right\|^{2}} i=1∑N[1−yi(w⋅xi+b)]++λ∥w∥2

目标函数的第一项是经验损失或经验风险函数，函数

L ( y i ( w ⋅ x i + b ) ) = [ 1 − y i ( w ⋅ x i + b ) ] + \mathbf{L}\left( y_{i}\left( w \cdot x_{i} + b \right) \right)\mathbf{=}\left\lbrack 1 - y_{i}\left( w \cdot x_{i} + b \right) \right\rbrack_{+} L(yi(w⋅xi+b))=[1−yi(w⋅xi+b)]+

称为合页损失函数

[ z ] + = { z , z > 0 0 , z ≤ 0 \left\lbrack \mathbf{z} \right\rbrack^{\mathbf{+}}\mathbf{=}\left\{ \begin{matrix} \mathbf{z,\ \ \ \ z > 0} \\ \mathbf{0,\ \ \ \ \ z \leq 0} \\ \end{matrix} \right.\ [z]+={z, z>00, z≤0

也就是说当样本点被正确分裂且分类间隔大于1时损失为0，否则损失为 1 − y i ( w ⋅ x i + b ) 1 - y_{i}\left( w \cdot x_{i} + b \right) 1−yi(w⋅xi+b)目标函数的第二项是系数为λ的w的 L 2 L_{2} L2范数，是正则化项。由此可见合页损失函数对学习有更高的要求。

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

核技巧：

由于非线性问题不好求解，所以希望能够用线性的方法来解决非线性的问题，而核技巧便是一种变换将原空间的数据映射到新空间。核技巧应用到支持向量机，基本思想是通过一个非线性变换将输入空间对应到一个特征空间，使得输入中的超曲面模型对应于特征空间中的超平面模型（支持向量机）。

核函数：

设 X X X是输入空间，又设 H H H为特征空间，如果存在一个从 X X X到 H H H的映射

ϕ （ x ） : X ⟶ H \phi\left. （x \right.）:X \longrightarrow H ϕ（x）:X⟶H

使得对所有 x , z ∈ X x,z \in X x,z∈X,函数 K ( x , z ) K(x,z) K(x,z)满足条件

K ( x , z ) = ϕ （ x ） ⋅ ϕ （ z ） K\left( x,z \right) = \phi\left. （x \right.） \cdot \phi\left. （z \right.） K(x,z)=ϕ（x）⋅ϕ（z）

则称 K ( x , z ) K(x,z) K(x,z)为核函数， ϕ （ x ） \phi\left. （x \right.） ϕ（x）为映射函数，式中 ϕ （ x ） ⋅ ϕ （ z ） \phi\left. （x \right.） \cdot \phi\left. （z \right.） ϕ（x）⋅ϕ（z）为$\phi\left. （x \right.）\ 和和和\phi\left. （z \right.）$的内积。

只定义核函数 K ( x , z ) K(x,z) K(x,z)而不是显示的定义映射函数 ϕ \phi ϕ。，通常,直接计算 K ( x , z ) K(x,z) K(x,z)比较容易，同时特征空间 H H H和映射函数 ϕ \phi ϕ的取法并不唯一，可以取不同的特征空间，即便是在同一特征空间里可以取不同的映射

实际中，我们注意到线性支持向量机的对偶问题中，无论是目标函数还是决策函数都只涉及输入和输出实例之间的内积。 x i ⋅ x j x_{i} \cdot x_{j} xi⋅xj可以用核函数 K ( x i , x j ) = ϕ （ x i ） ⋅ ϕ （ x j ） K\left( x_{i},x_{j} \right) = \phi\left. （x_{i} \right.） \cdot \phi\left. （x_{j} \right.） K(xi,xj)=ϕ（xi）⋅ϕ（xj）来代替。此时对偶问题的目标函数成为：

W ( α ) = 1 2 ∑ i = 1 N ∑ j = 1 N α i α j y i y i K ( x i , x j ) − ∑ i = 1 N α i W\left( \alpha \right) = \frac{1}{2}\sum_{i = 1}^{N}{\sum_{j = 1}^{N}{\alpha_{i}\alpha_{j}y_{i}y_{i}K\left( x_{i},x_{j} \right)} - \sum_{i = 1}^{N}\alpha_{i}} W(α)=21i=1∑Nj=1∑NαiαjyiyiK(xi,xj)−i=1∑Nαi

同理分类决策函数变为：

f ( x ) = s i g n ( ∑ i = 1 N s α i ∗ y i K ( x i , x ) + b ∗ ) f\left( x \right) = sign(\sum_{i = 1}^{N_{s}}{\alpha_{i}^{*}y_{i}K\left( x_{i},x \right)} + b^{*}) f(x)=sign(i=1∑Nsαi∗yiK(xi,x)+b∗)

也就是说在 K ( x , z ) K\left( x,z \right) K(x,z)给定的条件下，可以利用线性分类方法解决非线性分类的支持向量机。学习是隐式的不需要显式地定义特征空间和映射函数。这样的技巧称为核技巧，实际应用中往往会根据领域知识直接给出核函数。

常用的核函数：

多项式核函数
高斯核函数
字符串核函数（在文本分类、信息检索、生物信息学方面都有应用）

非线性支持向量机算法：

选取适当的核函数 K ( x , z ) K\left( x,z \right) K(x,z)和适当的参数 C C C,构造并求解最优化

min ⁡ α 1 2 ∑ i = 1 N ∑ j = 1 N α i α j y i y i K ( x i , x j ) − ∑ i = 1 N α i \min_{\alpha}{\text{\ \ }\frac{1}{2}\sum_{i = 1}^{N}{\sum_{j = 1}^{N}{\alpha_{i}\alpha_{j}y_{i}y_{i}K\left( x_{i},x_{j} \right)} - \sum_{i = 1}^{N}\alpha_{i}}} αmin 21i=1∑Nj=1∑NαiαjyiyiK(xi,xj)−i=1∑Nαi

s.t. ∑ i = 1 N α i y i = 0 , 0 ≤ a i y i ≤ C , i = 1 , 2 ⋯ , N \text{s.t.}\sum_{i = 1}^{N}{\alpha_{i}y_{i}} = 0,\ \ \ \ 0 \leq a_{i}y_{i} \leq C,i = 1,2\cdots,N s.t.i=1∑Nαiyi=0, 0≤aiyi≤C,i=1,2⋯,N

求得最优解 a ∗ = ( a 1 ∗ , a 2 ∗ , ⋯ , a N ∗ ) T a^{*} = {(a_{1}^{*},a_{2}^{*},\cdots,a_{N}^{*})}^{T} a∗=(a1∗,a2∗,⋯,aN∗)T

b ∗ = y j − ∑ i = 1 N a i ∗ y i K ( x i , x j ) b^{*} = y_{j} - \sum_{i = 1}^{N}{{a_{i}}^{*}y_{i}K(x_{i},x_{j})} b∗=yj−i=1∑Nai∗yiK(xi,xj)

构造决策函数：

f ( x ) = s i g n ( ∑ i = 1 N s α i ∗ y i K ( x , x i ) + b ∗ ) f\left( x \right) = sign(\sum_{i = 1}^{N_{s}}{\alpha_{i}^{*}y_{i}K\left( {x,x}_{i} \right)} + b^{*}) f(x)=sign(i=1∑Nsαi∗yiK(x,xi)+b∗)

当 K ( x , z ) K(x,z) K(x,z)是正定核函数时，上述问题是凸二次规划问题，解是存在的。

由上述所述，支持向量机学习就转化为求凸二次规划问题，有很多优化算法可用于求解。然而样本容量很大时，很多算法就会难以使用。下面介绍其中一种快速实现支持向量机的算法SMO算法：

SMO算法：

取初始值 a ( 0 ) = 0 , a^{(0)} = 0, a(0)=0,令 k = 0 k = 0 k=0;
选取优化变量 a 1 ( k ) , a 2 ( k ) a_{1}^{(k)},a_{2}^{(k)} a1(k),a2(k),（第一个变量可以选间隔边界上的支持向量点中最不满足KKT条件的，第二个变量由于依赖于 ∣ E 1 − E 2 ∣ \left| E_{1} - E_{2} \right| ∣E1−E2∣，因此可以选取 ∣ E 1 − E 2 ∣ \left| E_{1} - E_{2} \right| ∣E1−E2∣最大的，若目标函数没有满足对应的下降，则依次扩大搜索范围；若仍旧找不到，则放弃第一个变量，通过外层循环寻找另一个 a 1 a_{1} a1）;
求得最优解 a 1 ( k + 1 ) , a 2 ( k + 1 ) a_{1}^{(k + 1)},a_{2}^{(k + 1)} a1(k+1),a2(k+1)，更新 a 为 a ( k + 1 ) a_{\ }^{\ }{为a}_{\ }^{(k + 1)} a 为a (k+1)；

不断循环下列步骤求出最优解：

a 2 new.unc = a 2 old + y 2 ( E 1 − E 2 ) η , 其中 η = K 11 + K 22 − 2 K 12 a_{2}^{\text{new.unc}} = a_{2}^{\text{old}} + \frac{y_{2}(E_{1}{- E}_{2})}{\eta},其中\eta = K_{11} + K_{22} - 2K_{12} a2new.unc=a2old+ηy2(E1−E2),其中η=K11+K22−2K12

剪辑后:

a 2 new = { H , a 2 new.unc > H a 2 new.unc , L ≤ a 2 new.unc ≤ H L , a 2 new.unc < L , a_{2}^{\text{new}} = \left\{ \begin{matrix} H,\ \ \ \ \ \ a_{2}^{\text{new.unc}} > H \\ a_{2}^{\text{new.unc}}{,L \leq a}_{2}^{\text{new.unc}} \leq H \\ L,\ \ \ \ \ \ \ \ a_{2}^{\text{new.unc}} < L \\ \end{matrix} \right.\ , a2new=⎩⎨⎧H, a2new.unc>Ha2new.unc,L≤a2new.unc≤HL, a2new.unc<L ,

a 1 new = a 1 old + y 1 y 2 ( a 2 old − a 2 new ) \ a_{1}^{\text{new}} = a_{1}^{\text{old}} + y_{1}y_{2}(a_{2}^{\text{old}} - a_{2}^{\text{new}}) a1new=a1old+y1y2(a2old−a2new)

若在精度范围内满足停机条件则跳到最后，反之令 k = k + 1 k = k + 1 k=k+1,转到第二步；
取 a ^ = a ( k + 1 ) \widehat{a} = \ a^{(k + 1)} a = a(k+1);

四、线性、非线性支持向量机实现实例

matlab源码：

（初始数据5*10个分格，每个格子中20个点，其中的数据为随机生成）

线性支持向量机源码：

%主函数

clear all;

clc;

C = 10;

kertype = ‘linear’;

%训练样本

n = 50;

randn(‘state’,6);%可以保证每次每次产生的随机数一样

x1 = randn(2,n); %2行N列矩阵

y1 = ones(1,n); %1*N个1

x2 = 5+randn(2,n); %2*N矩阵

y2 = -ones(1,n); %1*N个-1

figure;

plot(x1(1,:),x1(2,:),‘bx’,x2(1,:),x2(2,:),‘k.’);

axis([-3 8 -3 8]);

xlabel(‘x轴’);

ylabel(‘y轴’);

hold on;

X = [x1,x2]; %训练样本d*n矩阵，n为样本个数，d为特征向量个数，在这里，X为一个2*100的数组

Y = [y1,y2]; %训练目标1*n矩阵，n为样本个数，值为+1或-1，在这里，Y为一个1*100的数组

svm = svmTrain(X,Y,kertype,C);

plot(svm.Xsv(1,:),svm.Xsv(2,:),‘ro’);

%测试

[x1,x2] = meshgrid(-2:0.05:7,-2:0.05:7); %x1和x2都是181*181的矩阵

[rows,cols] = size(x1);

nt = rows*cols;

Xt = [reshape(x1,1,nt);reshape(x2,1,nt)];

Yt = ones(1,nt);

result = svmTest(svm, Xt, Yt, kertype);

Yd = reshape(result.Y,rows,cols);

contour(x1,x2,Yd,‘m’);

function K = kernel(X,Y,type)

%X 维数*个数

switch type

case ‘linear’

K = X’*Y;

case ‘rbf’

delta = 5;

delta = delta*delta;

XX = sum(X’.*X’,2);%sum(a,2)代码中参数2的意思是将a矩阵a中的按"行"为单位进行求和

YY = sum(Y’.*Y’,2);

XY = X’*Y;

K = abs(repmat(XX,[1 size(YY,1)]) + repmat(YY’,[size(XX,1) 1]) -
2*XY);

K = exp(-K./delta);

end

function svm = svmTrain(X,Y,kertype,C)

options = optimset; % Options是用来控制算法的选项参数的向量

options.LargeScale = ‘off’;%LargeScale指大规模搜索，off表示在规模搜索模式关闭

options.Display = ‘off’;%这样设置意味着没有输出

n = length(Y);%数组Y的长度

H = (Y’*Y).*kernel(X,X,kertype);%调用kernel函数，

f = -ones(n,1); %f为1*n个-1,f相当于Quadprog函数中的c

A = [];

b = [];

Aeq = Y; %相当于Quadprog函数中的A1,b1

beq = 0;

lb = zeros(n,1); %相当于Quadprog函数中的LB，UB

ub = C*ones(n,1);

a0 = zeros(n,1); % a0是解的初始近似值

[a,fval,eXitflag,output,lambda] =
quadprog(H,f,A,b,Aeq,beq,lb,ub,a0,options);

epsilon = 1e-8;

sv_label = find(abs(a)>epsilon); %0<a<a(max)则认为x为支持向量

svm.a = a(sv_label);

svm.Xsv = X(:,sv_label);

svm.Ysv = Y(sv_label);

svm.svnum = length(sv_label);

%svm.label = sv_label;

function result = svmTest(svm, Xt, Yt, kertype)

temp = (svm.a’.*svm.Ysv)*kernel(svm.Xsv,svm.Xsv,kertype);

total_b = svm.Ysv-temp;

b = mean(total_b);

w = (svm.a’.*svm.Ysv)*kernel(svm.Xsv,Xt,kertype);

result.score = w + b;

Y = sign(w+b);

result.Y = Y;

result.accuracy = size(find(Y==Yt))/size(Yt);

非线性支持向量机源码：

%------------主函数----------------

clear all;

close all;

C = 10; %成本约束参数

kertype = ‘rbf’; %rbf高斯核

%①------数据准备5*10方格，每个方格20个点，共1000个点

x1=[];

x3=[];

for i=0:1:9

for j=0:1:4

b=j+rand(20,1);%随机生成20个点

c=i+rand(20,1);

x0=[x1;b];

x2=[x3;c];

x1=x0; %这里的x1放所有点的横坐标

x3=x2; %x3放所有点的纵坐标,(x1,x3)

end

end

y0=[];%这个矩阵放所有点的标记

y1 = ones(20,1); %20个+1标记

y2 = -ones(20,1);%20个-1标记

for k=0:1:24 %循环赋值，使得5*10方格内相邻的格子标记都不一样

y0=[y0;y1];

y0=[y0;y2];

end

x1=x1.’;

x3=x3.’ ; %记得转置一下哦

figure; %创建一个用来显示图形输出的一个窗口对象

for m=1:1:25

plot(x1(1,(1+20*(2*m-2)):(20*(2*m-1))),x3(1,(1+20*(2*m-2)):(20*(2*m-1))),‘k.’);
%画图

hold on;

plot(x1(1,(1+20*(2*m-1)):(20*(2*m))),x3(1,(1+20*(2*m-1)):(20*(2*m))),‘b+’);
%画图

hold on; %在同一个figure中画几幅图时，用此句

end

%axis([0 5 0 10]); %设置坐标轴范围

%②-------------训练样本

X = [x1;x3]; %训练样本2*n矩阵，n为样本个数，d为特征向量个数

Y = y0.’; %训练目标1*n矩阵，n为样本个数，值为+1或-1

svm = svmTrain(X,Y,kertype,C); %训练样本

%%%把支持向量标出来,若支持向量画的不对，此时可通过在kernel函数调参来修改

for i=1:1:svm.svnum

if svm.Ysv(1,i)==1

plot(svm.Xsv(1,i),svm.Xsv(2,i),‘mo’);%一类支持向量用粉色圈住

else

plot(svm.Xsv(1,i),svm.Xsv(2,i),‘ko’);%另一类支持向量黑色圈

end

end

%plot(svm.Xsv(1,:),svm.Xsv(2,:),‘ro’);

%③-------------测试

[x1,x2] = meshgrid(0:0.05:5,0:0.05:10); %最大值控制着等高线在几乘几范围画出来

[rows,cols] = size(x1);

nt = rows*cols;

Xt = [reshape(x1,1,nt);reshape(x2,1,nt)];

%前半句reshape(x1,1,nt)是将x1转成1*（rows*cols）的矩阵，所以Xt是2*（rows*cols）的矩阵

%reshape函数重新调整矩阵的行、列、维数

y3 = ones(1,floor(nt/2));

y4 = -ones(1,floor(nt/2)+1);

Yt = [y3,y4];

result = svmTest(svm, Xt, Yt, kertype);

%④--------------画曲线的等高线图

Yd = reshape(result.Y,rows,cols);

contour(x1,x2,Yd,3); %产生三个水平的等高线

title(‘5*10数据分类’);

x1=xlabel(‘X轴’);

x2=ylabel(‘Y轴’);

%---------------核函数kernel---------------

function K = kernel(X,Y,type)

%X 维数*个数

switch type

case ‘linear’ %此时代表线性核

K = X’*Y;

case ‘rbf’ %此时代表高斯核

delta = 0.5; %改变这个参数图会变的不一样唉。。。越大支持向量越多。。。

delta = delta*delta;

XX = sum(X’.*X’,2); %2表示将矩阵中的按行为单位进行求和

YY = sum(Y’.*Y’,2);

XY = X’*Y;

K = abs(repmat(XX,[1 size(YY,1)]) + repmat(YY’,[size(XX,1) 1]) -
2*XY);

K = exp(-K./delta);

end

end

%-----------训练样本的函数svmTrain---------

function svm = svmTrain(X,Y,kertype,C)

% Options是用来控制算法的选项参数的向量，optimset无参时，创建一个选项结构所有字段为默认值的选项

options = optimset;

options.LargeScale = ‘off’;%LargeScale指大规模搜索，off表示在规模搜索模式关闭

options.Display = ‘off’; %表示无输出

%二次规划来求解问题，可输入命令help quadprog查看详情

n = length(Y); %返回Y最长维数

H = (Y’*Y).*kernel(X,X,kertype);

f = -ones(n,1); %f为1*n个-1,f相当于Quadprog函数中的c

A = [];

b = [];

Aeq = Y; %相当于Quadprog函数中的A1,b1

beq = 0;

lb = zeros(n,1); %相当于Quadprog函数中的LB，UB

ub = C*ones(n,1);

a0 = zeros(n,1); % a0是解的初始近似值

[a,fval,eXitflag,output,lambda] =
quadprog(H,f,A,b,Aeq,beq,lb,ub,a0,options);

%a是输出变量，问题的解

%fval是目标函数在解a处的值

%eXitflag>0,则程序收敛于解x；=0则函数的计算达到了最大次数；<0则问题无可行解，或程序运行失败

%output输出程序运行的某些信息

%lambda为在解a处的值Lagrange乘子

epsilon = 1e-8;

%0<a<a(max)则认为x为支持向量,find返回一个包含数组X中每个非零元素的线性索引的向量。

sv_label = find(abs(a)>epsilon);

svm.a = a(sv_label);

svm.Xsv = X(:,sv_label);

svm.Ysv = Y(sv_label);

svm.svnum = length(sv_label);

%svm.label = sv_label;

end

%---------------测试的函数svmTest-------------

function result = svmTest(svm, Xt, Yt, kertype)

temp = (svm.a’.*svm.Ysv)*kernel(svm.Xsv,svm.Xsv,kertype);

%total_b = svm.Ysv-temp;

b = mean(svm.Ysv-temp); %b取均值

w = (svm.a’.*svm.Ysv)*kernel(svm.Xsv,Xt,kertype);

result.score = w + b;

Y = sign(w+b); %f(x)

result.Y = Y;

result.accuracy = size(find(Y==Yt))/size(Yt);

end

实验结果：

线性支持向量机

数据源

非线性支持向量机

其中圈出的点为支持向量，绿色线为二分类最大分割超平面；

初始数据5*10个分格，每个格子中20个点；