title: 统计学习方法
date: 2021-06-20 12:33:57
tags:
概论
统计学习由监督学习、无监督学习、半监督学习和强化学习组成
统计学习的三要素：模型、策略和算法
在本书中主要研究的是监督学习。
在监督学习中，输入和输出可能取值的集合称为输入空间和输出空间，每个输入是一个实例，由特征向量组成。符号表示如下：
x = ( x ( 1 ) , x ( 2 ) , . . . , x ( i ) , . . . , x ( n ) ) T x=(x^{(1)},x^{(2)},...,x^{(i)},...,x^{(n)})^T x=(x(1),x(2),...,x(i),...,x(n))T
x i = ( x i ( 1 ) , x i ( 2 ) , . . . , x i ( i ) , . . . , x i ( n ) ) T x_i = (x_i^{(1)},x_i^{(2)},...,x_i^{(i)},...,x_i^{(n)})^T xi=(xi(1),xi(2),...,xi(i),...,xi(n))T
注意两者的区别，前者是一个输入向量，后者指的是多个输入向量中的第i个，小写的"x"表示特征。对于输出向量同理，只是字母变成了“y”。
数据集的表示：
T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T = \{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1,y1),(x2,y2),...,(xN,yN)}
监督学习的目的就是获得一个概率或非概率模型：
P
(
X
∣
Y
)
/
y
=
f
(
x
)
P(X|Y) /y=f(x)
P(X∣Y)/y=f(x)
接下来依次分析统计学习的三要素：
模型
模型就是所要学习的条件概率或决策函数，但实际上，符合条件的模型并不是唯一的，而是存在一个假设空间，一般有无穷多个。符号表示如下：
ϝ
=
{
f
∣
Y
=
f
(
X
)
}
\digamma = \{f|Y=f(X)\}
ϝ={f∣Y=f(X)}
ϝ
=
{
P
∣
P
(
Y
∣
X
)
}
\digamma = \{P|P(Y|X)\}
ϝ={P∣P(Y∣X)}
策略
策略是选择模型或学习的准则。对于预测的得到的结果，可能会与实际数据有所偏差，我们用一个损失函数来度量预测错误的程度，记作：
L
(
Y
,
f
(
X
)
)
L(Y,f(X))
L(Y,f(X))
实际上，存在有多种损失函数用于使用，同时由于其不同的特点，应用场合和效果也会有所不同。
0-1损失函数
L
(
Y
,
f
(
X
)
)
=
{
1
,
Y
≠
f
(
X
)
0
,
Y
=
f
(
X
)
L(Y,f(X)) = \begin{cases} 1,Y \neq f(X) \\0,Y = f(X) \end{cases}
L(Y,f(X))={1,Y=f(X)0,Y=f(X)
平方损失函数
L
(
Y
,
f
(
X
)
)
=
(
Y
−
f
(
X
)
)
2
L(Y,f(X)) = (Y-f(X))^2
L(Y,f(X))=(Y−f(X))2
决定损失函数
L
(
Y
,
f
(
X
)
)
=
∣
Y
−
f
(
x
)
∣
L(Y,f(X)) = |Y-f(x)|
L(Y,f(X))=∣Y−f(x)∣
对数损失函数
L
(
Y
,
P
(
Y
∣
X
)
)
=
−
l
o
g
P
(
Y
∣
X
)
L(Y,P(Y|X)) = -logP(Y|X)
L(Y,P(Y∣X))=−logP(Y∣X)
得到的损失函数，只能表示单一数据的评估，对于多组数据，我们利用损失函数的期望，即：
R
e
x
p
(
f
)
=
E
p
[
L
(
Y
,
f
(
X
)
)
]
=
∫
x
∗
y
L
(
y
,
f
(
x
)
)
P
(
x
,
y
)
d
x
d
y
R_{exp}(f) = E_p[L(Y,f(X))] = \int_{x*y}L(y,f(x))P(x,y)dxdy
Rexp(f)=Ep[L(Y,f(X))]=∫x∗yL(y,f(x))P(x,y)dxdy
这个公式的理解难度不大，但是问题来了，
P
(
x
,
y
)
P(x,y)
P(x,y)是x和y的联合分布，但是由于
P
(
x
,
y
)
P(x,y)
P(x,y)是未知的，所以求不出
R
e
x
p
R_{exp}
Rexp而如果知道
P
(
x
,
y
)
P(x,y)
P(x,y)，我们就能求得
P
(
X
∣
Y
)
P(X|Y)
P(X∣Y)，显然出现了矛盾。
在这种情况下，我们不得不使用统计学的大法：经验风险(实际上就是令
P
(
x
,
y
)
=
1
N
P(x,y) = \frac{1}{N}
P(x,y)=N1)：
R
e
m
p
(
f
)
=
1
N
∑
i
=
1
N
L
(
y
i
,
f
(
x
i
)
)
R_{emp}(f) = \frac{1}{N}\sum^N_{i=1}L(y_i,f(x_i))
Remp(f)=N1i=1∑NL(yi,f(xi))
根据大数定律，当样本容量N趋近于无穷时 R e m p R_{emp} Remp近似于 R e x p R_{exp} Rexp。
因而，只需求得最小的 R e m p R_{emp} Remp即可得到合适的模型，现实中最大似然估计就是经验风险最小化的一个体现。
为什么说最大似然估计是经验风险最小化的一个体现？
最大似然估计我们在概率论的时候已经接触过了，即：
L
(
θ
)
=
∏
i
=
1
n
p
(
x
;
θ
)
L(\theta) = \prod_{i=1}^np(x;\theta)
L(θ)=i=1∏np(x;θ)
其思想就是找到一个参数使得损失函数最大。经验风险最小化也类似，只不过是找到参数使得其为最小值。
上述准则似乎可以满足一切问题，但是实际并非如此。当样本容量较小时，我们发现通过这种方式学习得到的模型会出现过拟合的问题。所以要存在另一个方法：结构风险：
R
s
r
m
(
f
)
=
1
N
∑
i
=
1
N
L
(
y
i
,
f
(
x
i
)
)
+
λ
J
(
f
)
R_{srm}(f) = \frac{1}{N}\sum^N_{i=1}L(y_i,f(x_i))+\lambda J(f)
Rsrm(f)=N1i=1∑NL(yi,f(xi))+λJ(f)
我们可以清楚的看到，经验风险和结构风险两者之间其实并未存在较大的区别，相较于前者，后者增加了一个模型复杂度
J
(
f
)
J(f)
J(f)，
λ
\lambda
λ是其中的系数用于权衡经验风险和模型复杂度。
通过上述的两个风险函数，我们将监督问题转换为了经验风险和结构风险函数的最优化问题。这时候两个函数是最优化的目标函数
算法
算法指的是学习模型的具体计算方法。这里算法主要解决的是最优化问题的解法，实际上最优解问题通常没有显示的解析解，且存在找不到全局最优解的问题。因而需要最优化算法。
模型评估
基于上述的风险函数，我们对模型进行评估。当损失函数给定的时候，训练误差和测试误差自然的就会成为学习方法评估的标准（这里有个细节，学习时采用的损失函数与评估时的损失函数未必相同）。
假设学习得到模型是 Y = f ^ ( x ) Y = \hat{f}(x) Y=f^(x)，那么关于训练集和数据集的平均误差：
R e m p ( f ^ ) = 1 N ∑ i = 1 N L ( y i , f ^ ( x i ) ) R_{emp}(\hat{f})=\frac{1}{N}\sum_{i=1}^NL(y_i,\hat{f}(x_i)) Remp(f^)=N1i=1∑NL(yi,f^(xi))
e t e s t = 1 N ′ ∑ i = 1 N ′ L ( y i , f ^ ( x i ) ) e_{test}=\frac{1}{N'}\sum_{i=1}^{N'}L(y_i,\hat{f}(x_i)) etest=N′1i=1∑N′L(yi,f^(xi))
其中N和N’分别为训练样本容量和测试样本容量。然而，上述的评估方法只不过是其中的一个指标，显然，当 e t e s t e_{test} etest较小时模型比较好，存在的另一个东西叫做泛化能力。
用大白话讲，泛化就是通过训练得到的模型，在测试集上的效果如何。如果在训练集的效果上较好但是在测试集上不好，那就是过拟合问题，相反则是欠拟合问题。
训练误差与测试误差和模型复杂度的关系是容易理解的，对于训练误差，随着模型逐渐复杂，模型可以精准的传过每一个点，从而最终使得训练误差达到极小的情况，但是对于测试误差，在达到一定的复杂度时，测试误差会随着复杂度的增加而增加，从而弱化了泛化能力。
那么如何选择一个较为合适的复杂度，有两种方法：正则化、交叉验证
正则化
实际上，正则化的形式在结构风险函数中已经有所体现（貌似长得一样）。在正则化中也存在两种方法：L1正则和L2正则。两者就是在经验风险函数的末尾加上L1正则项和L2正则项。我们以线性回归为例，两种正则的形式如下：
L ( w ) = 1 N ∑ i = 1 N ( f ( x i ; w ) − y i ) 2 + λ 2 ∣ ∣ w ∣ ∣ 2 L(w) = \frac{1}{N}\sum ^N_{i=1}(f(x_i;w)-y_i)^2 +\frac{\lambda}{2}||w||^2 L(w)=N1i=1∑N(f(xi;w)−yi)2+2λ∣∣w∣∣2
L ( w ) = 1 N ∑ i = 1 N ( f ( x i ; w ) − y i ) 2 + λ ∣ ∣ w ∣ ∣ 1 L(w) = \frac{1}{N}\sum ^N_{i=1}(f(x_i;w)-y_i)^2 +\lambda||w||_1 L(w)=N1i=1∑N(f(xi;w)−yi)2+λ∣∣w∣∣1
前者是L2正则，后者是L1正则。这里回顾一下结构风险函数提出的意义，当输入实例较少时且模型过于复杂时，我们很容易就能得到一个较小的经验风险函数，但是显然是过拟合的，通过假如L1正则项，当复杂度较高时，会增大误差，从而降低拟合程度。
相关阅读：L1正则化和L2正则化
交叉验证
这是数据集中数据切分的方案：分别为简单交叉验证、S折交叉验证、留一交叉验证。
这部分内容不进行赘述。
泛化能力
从定义上来看，泛化能力指的是该方法学习到的模型对未知数据的预测能力。就从定义上来看，显然，如何最大化泛化能力才是学习的最终目的，那么这一概念与前文提到的内容是否冲突？泛化误差的形式如下：
R e x p ( f ^ ) = E p [ L ( Y , f ^ ( x ) ) ] = ∫ x ∗ y L ( y , f ^ ( x ) ) P ( x , y ) d x d y R_{exp}(\hat{f}) = E_p[L(Y,\hat{f}(x))] = \int_{x*y}L(y,\hat{f}(x))P(x,y)dxdy Rexp(f^)=Ep[L(Y,f^(x))]=∫x∗yL(y,f^(x))P(x,y)dxdy
从形式上来看，泛化误差实际上就是模型的期望风险。对于泛化误差，我们通常比较泛化误差上界的大小来比较优劣。误差上界函数是关于样本容量的函数，容量越大，模型越难学，误差上界越大。
泛化误差上界定理：若从函数族 ϝ \digamma ϝ中任选出函数 f f f，至少有概率 1 − σ 1-\sigma 1−σ，使下列不等式成立：
R ( f ) ≤ R ^ ( f ) + ϵ ( d , N , σ ) R(f) \leq \hat{R}(f) + \epsilon(d,N,\sigma) R(f)≤R^(f)+ϵ(d,N,σ)
其 中 ϵ ( d , N , σ ) = 1 2 N ( log d + log 1 σ ) 其中 \epsilon(d,N,\sigma) = \sqrt{\frac{1}{2N}(\log d + \log \frac{1}{\sigma})} 其中ϵ(d,N,σ)=2N1(logd+logσ1)
在上述不等式中，不等式左侧为泛化误差，右侧为上界。右侧的第一项是训练的误差，第二项是N的单调递减函数。
生成模型和判别模型
对于监督学习，就其模型学得的种类分为生成模型和判别模型。
前者主要是根据条件概率公式，在求得 P ( X , Y ) P(X,Y) P(X,Y)之后利用条件概率公式即可。
判别模型这是直接生成决策函数 f ( X ) f(X) f(X)或者 P ( X ∣ Y ) P(X|Y) P(X∣Y)。
监督学习解决问题的种类
分类、标注、回归
三者解决的问题不同，过程也存在一定的差异，在此不多赘述。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Zrsp4g6H-1626781614239)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194156.png?token=AN7NJ7LEEUCLDR7MYDPVFCTA623ME)]
感知机
感知机是一种二分类的线性分类模型。说起来可能比较抽象，我们先看看它的定义：
感知机：假设输入空间
X
⊆
R
n
\Chi \subseteq R^n
X⊆Rn，输出空间是
Y
=
+
1
,
−
1
Y = {+1,-1}
Y=+1,−1输入
x
∈
X
x \in X
x∈X表示实力的特征向量，对应于输入控件的点：输出
y
∈
Y
y\in Y
y∈Y表示实例的类别，由输入空间到输出空间的如下函数：
f
(
x
)
=
s
i
g
n
(
ω
⋅
x
+
b
)
f(x) = sign(\omega \cdot x+b)
f(x)=sign(ω⋅x+b)
称为感知机。其中 ω \omega ω和 b b b叫做感知机模型参数。 ω \omega ω表示权值或权值向量， b ∈ R b \in R b∈R叫做偏置。 s i g n ( x ) sign(x) sign(x)为符号函数，即:
s i g n ( x ) { + 1 , x ≥ 0 − 1 , x < 0 sign(x) \begin{cases} +1,x\geq 0\\-1,x<0 \end{cases} sign(x){+1,x≥0−1,x<0
如果对神经网络有所理解的话，这其实就是一个神经元。
通过上述的定义，我们暂且可以将一个感知机看作一个分类器，不同的数据进去可以得到1或-1。根据 ω \omega ω的维度不同，$\omega \cdot x+b $是一个空间的超平面，将空间分为两类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iPGMdwfe-1626781614240)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194207.png?token=AN7NJ7L7U7L2YATI5RF3CODA623M4)]
稍微有点知识就能知道，通过一组训练数据集，我们就可以拟合出一个较为合适的 ω \omega ω和 b b b
感知机学习策略
首先我们要知道数据集是否具有线性可分性的，这一点可以参见下图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MvMayNpe-1626781614242)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194217.png?token=AN7NJ7IDO3PSLFN4DVMH6M3A623NM)]
所谓的线性可分可见左边的图片，显然，我们可以通过一条直线将两类数据分开。对于右图线性不可分的情况，我们无法使用一条直线将两类数据分开。
那么假设现在一个数据集是线性可分的，那么感知机的目标是为了获得一个能将数据级完全分开的超平面。我们需要定义一个学习策略，根据我们在第一章中了解的。所谓策略，其实就是一个损失函数和一个风险函数的最小化，那么感知机的损失函数如何获取？
有两个思路，一是获取误分类点的个数，但是这样的问题是，总数并不是 ω \omega ω和 b b b的可导函数，没办法进行优化。因而我们使用另一个思路，获取误分类点道超平面的距离。
首先，对于任意一点 x 0 x_0 x0，该点到超平面的距离
1 ∣ ∣ ω ∣ ∣ ∣ ω ⋅ x 0 + b ∣ \frac{1}{||\omega||}|\omega \cdot x_0+b| ∣∣ω∣∣1∣ω⋅x0+b∣
其中 ∣ ∣ ω ∣ ∣ ||\omega|| ∣∣ω∣∣是 ω \omega ω的 L 2 L_2 L2范数。
-
L 0 L_0 L0范数：非0元素的个数
-
L 1 L_1 L1范数：各个元素绝对值的和
-
L 2 L_2 L2范数：各个元素平方和的平方根
-
所谓范数，实际上可以理解为长度
对于误分类的数据，我们可以得到：
− y i ( ω ⋅ x i + b ) > 0 -y_i(\omega \cdot x_i +b) >0 −yi(ω⋅xi+b)>0
这是由于误分类的点与期望分类的符号相反，所以两者之积应该小于0
所以误分类点到超平面的总距离：
1 ∣ ∣ ω ∣ ∣ y i ( ω ⋅ x 0 + b ) \frac{1}{||\omega||}y_i(\omega \cdot x_0+b) ∣∣ω∣∣1yi(ω⋅x0+b)
所有误分类点到超平面的总距离：
− 1 ∣ ∣ ω ∣ ∣ ∑ x i ∈ M y i ( ω ⋅ x 0 + b ) -\frac{1}{||\omega||}\sum_{x_i \in M}y_i(\omega \cdot x_0+b) −∣∣ω∣∣1xi∈M∑yi(ω⋅x0+b)
不考虑 1 ∣ ∣ ω ∣ ∣ \frac{1}{||\omega||} ∣∣ω∣∣1就可以得到损失函数。
所以，对于感知机 s i g n ( ω ⋅ x i + b ) sign(\omega \cdot x_i+b) sign(ω⋅xi+b)的损失函数：
L ( ω , b ) = − ∑ x i ∈ M y i ( ω ⋅ x i + b ) L(\omega,b) = -\sum_{x_i \in M}y_i(\omega \cdot x_i+b) L(ω,b)=−xi∈M∑yi(ω⋅xi+b)
其中M为误分类点的点集。
感知机学习算法
在获得了学习策略之后，我们要使用合适的算法对其进行迭代，即实现：
min ω , b L ( ω , b ) = − ∑ x i ∈ M y i ( ω ⋅ x i + b ) \min_{\omega,b}L(\omega , b) = -\sum_{x_i \in M}y_i(\omega \cdot x_i+b) ω,bminL(ω,b)=−xi∈M∑yi(ω⋅xi+b)
易得知，感知机学习的算法是误分类驱动的。在书中使用了随机梯度下降法。具体方案为，任选一个超平面 ω 0 \omega_0 ω0和 b 0 b_0 b0，一次随机选取一个误分类点，使其梯度下降。
那么损失函数的梯度：
∇ ω L ( ω , b ) = − ∑ x i ∈ M y i x i \nabla_\omega L(\omega,b) = -\sum_{x_i \in M}y_ix_i ∇ωL(ω,b)=−xi∈M∑yixi
∇ ω L ( ω , b ) = − ∑ x i ∈ M y i \nabla_\omega L(\omega,b) = -\sum_{x_i \in M}y_i ∇ωL(ω,b)=−xi∈M∑yi
具体算法如下：
-
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1,y1),(x2,y2),...,(xN,yN)}，其中 x i ∈ X = R n , y i ∈ Y = { − 1 , + 1 } , i = 1 , 2 , . . . , N x_i \in \Chi = R^n,y_i \in Y=\{-1,+1\},i=1,2,...,N xi∈X=Rn,yi∈Y={−1,+1},i=1,2,...,N；学习率 η ( 0 < η ≤ 1 ) ; \eta(0<\eta\leq1); η(0<η≤1);
-
输出： ω , b \omega,b ω,b；感知机模型 f ( x ) = s i g n ( ω ⋅ x + b ) f(x) = sign(\omega\cdot x+b) f(x)=sign(ω⋅x+b)
-
(1)选取初值 ω 0 , b 0 \omega_0,b_0 ω0,b0
-
(2)在训练集中选取数据 ( x i , y i ) (x_i,y_i) (xi,yi)
-
(3)如果 y i ( ω ⋅ x i + b ) ≤ 0 y_i(\omega \cdot x_i+b)\leq0 yi(ω⋅xi+b)≤0
ω ← ω + η y i x i \omega\leftarrow\omega+\eta y_ix_i ω←ω+ηyixi
b ← b + η y i b \leftarrow b+\eta y_i b←b+ηyi
-
(4)转至(2)直至训练集中没有误分类点。
整个过程并非十分困难，可以参考P30页的例子。
上述的学习算法是感知机学习算法的原始形式，既然如此，那么实际上确实还有一种形式，叫对偶形式。
相较于原始形式，对偶形式的基本想法是将 ω \omega ω和 b b b表示为x和y的线性组合形式，通过求解系数从而获得 ω \omega ω和 b b b的值（这里应该用到了线性代数的思想）
算法如下：
-
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1,y1),(x2,y2),...,(xN,yN)}，其中 x i ∈ X = R n , y i ∈ Y = { − 1 , + 1 } , i = 1 , 2 , . . . , N x_i \in \Chi = R^n,y_i \in Y=\{-1,+1\},i=1,2,...,N xi∈X=Rn,yi∈Y={−1,+1},i=1,2,...,N；学习率 η ( 0 < η ≤ 1 ) ; \eta(0<\eta\leq1); η(0<η≤1);
-
输出： α , b \alpha,b α,b；感知机模型 f ( x ) = s i g n ( ∑ j = 1 N α j y j x j ⋅ x + b ) f(x) = sign(\sum_{j=1}^N\alpha_jy_jx_j\cdot x+b) f(x)=sign(∑j=1Nαjyjxj⋅x+b)其中 α = ( α 1 , α 2 , . . . , α N ) T \alpha = (\alpha_1,\alpha_2,...,\alpha_N)^T α=(α1,α2,...,αN)T
-
(1) α ← 0 , b ← 0 \alpha \leftarrow 0 ,b \leftarrow 0 α←0,b←0
-
(2)在训练集中选取数据 ( x i , y i ) (x_i,y_i) (xi,yi)
-
(3)如果 y i ( ∑ j = 1 N α j y j x j ⋅ x + b ) ≤ 0 y_i(\sum_{j=1}^N\alpha_jy_jx_j\cdot x+b)\leq0 yi(∑j=1Nαjyjxj⋅x+b)≤0
α i ← α i + η \alpha_i\leftarrow\alpha_i+\eta αi←αi+η
b ← b + η y i b \leftarrow b+\eta y_i b←b+ηyi
-
(4)转至(2)直至训练集中没有误分类点。
对偶形式中的训练实例仅以内积的形式出现，为了方便，可以预先将训练集中的实力间的内积计算出来并以矩阵的形式存储，这个矩阵就是所谓的Gram矩阵：
G = [ x i ⋅ x j ] N ∗ N G = [x_i \cdot x_j]_{N*N} G=[xi⋅xj]N∗N
学习算法的收敛性
感知机学习算法的收敛性是指通过有限的迭代，可以得到一个将训练数据集完全正确划分的分离超平面及感知机模型
如何证明感知机的学习算法具有收敛性。我们令$\hat{\omega}=(\omegaT,b)T ， 同 时 为 输 入 向 量 扩 充 加 入 常 数 1 ， 得 到 ，同时为输入向量扩充加入常数1，得到 ，同时为输入向量扩充加入常数1，得到\hat{x} = (xT,1)T 可 以 知 道 ， 可以知道， 可以知道，\hat{\omega} \cdot \hat{x} = \omega \cdot x +b$
那么存在定理（Novikoff定理）
-
存在满足条件的的 ∣ ∣ ω ^ o p t ∣ ∣ = 1 ||\hat{\omega}_{opt}||=1 ∣∣ω^opt∣∣=1的超平面 ω ^ o p t ⋅ x ^ = ω o p t ⋅ x + b o p t = 0 \hat{\omega}_{opt} \cdot \hat{x} = \omega_{opt} \cdot x +b_{opt}=0 ω^opt⋅x^=ωopt⋅x+bopt=0将训练数据集完全正确分开；且存在 γ > 0 \gamma >0 γ>0，对所有的 i = 1 , 2 , . . . , N i=1,2,...,N i=1,2,...,N
y i ( ω ^ o p t ⋅ x ^ ) = y i ( ω o p t ⋅ x + b o p t ) ≥ γ y_i(\hat{\omega}_{opt} \cdot \hat{x}) =y_i( \omega_{opt} \cdot x +b_{opt})\geq \gamma yi(ω^opt⋅x^)=yi(ωopt⋅x+bopt)≥γ
-
令 R = m a x 1 ≤ i ≤ N ∣ ∣ x ^ i ∣ ∣ R=max_{1\leq i\leq N}||\hat{x}_i|| R=max1≤i≤N∣∣x^i∣∣，则感知机算法在训练集上无分类次数k满足不等式：
k ≤ ( R γ ) 2 k \leq (\frac{R}{\gamma})^2 k≤(γR)2
由于证明过程较为繁杂，在这里不进行一步一步的列举。详见后文证明。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-74RFc3Tw-1626781614244)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194227.png?token=AN7NJ7PZ5FCSG3CA5HGSKCLA623OC)]
k近邻法
k近邻法的输入为实例的特征向量，输出为类别，且可以取多类。实际上其是将特征向量空间进行一个划分作为模型。相较于感知机，k近邻法的三个基本要素是：k值的选择、距离度量和分类决策规则。
k近邻算法
实际上，k近邻算法并不难理解。
-
输入：训练数据集 T = { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x N , y N ) } T=\{(x_1,y_1),(x_2,y_2),...,(x_N,y_N)\} T={(x1,y1),(x2,y2),...,(xN,yN)}，其中，$x_i\in\Chi \subseteq R^n 为 实 例 的 特 征 向 量 ， 为实例的特征向量， 为实例的特征向量，y_i \in Y = {c_1,c_2,…,c_K} 为 实 例 的 类 别 ， 为实例的类别， 为实例的类别，i=1,2,…,N$;
-
输出：实例x所属的类y
-
(1)根据给定的距离度量，在训练集T中中找出与x最邻近的k个点，涵盖这k个点的x的邻域记作 N k ( x ) N_k(x) Nk(x)；
-
(2)在 N k ( x ) N_k(x) Nk(x)根据分类决策规则决定x的类别y： y = a r g m a x c j ∑ x i ∈ N k ( x ) I ( y i = c j ) , i = 1 , 2 , . . . , N ; j = 1 , 2 , . . . , K y = argmax_{c_j}\sum_{x_i \in N_k(x)}I(y_i = c_j),i=1,2,...,N;j=1,2,...,K y=argmaxcjxi∈Nk(x)∑I(yi=cj),i=1,2,...,N;j=1,2,...,K
其中 I I I为指示函数
-
下面这张图可以帮助你直观的理解k邻近法的模型：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zzLc1COd-1626781614246)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194234.png?token=AN7NJ7LXGSZGF5X2PPYMZVLA623OS)]
接下来基于三要素对k近邻模型进行一个分析
距离度量
说到距离，我们通常使用平方和的平方根作为距离，我们一般将其称为欧氏距离。我们使用一个 L p L_p Lp距离来表示更一般的情况。
因为懒得写很多集合和维度的数据，设特征空间中存在两个实例 x i , x j x_i,x_j xi,xj，那么两者的 L P L_P LP距离定义为：
L p ( x i , x j ) = ( ∑ l = 1 n ∣ x i ( l ) − x j ( l ) ∣ p ) 1 p L_p(x_i,x_j) = (\sum^n_{l=1}|x_i^{(l)}-x_j^{(l)}|^p)^{\frac{1}{p}} Lp(xi,xj)=(l=1∑n∣xi(l)−xj(l)∣p)p1
我们很容易就能看出来，当p=2时就是我们常用的两点距离公式，即欧氏距离。
当p=1时为曼哈顿距离，当 p = ∞ p=\infin p=∞时各个坐标距离的最大值。 L p L_p Lp距离间的关系如下图：
从这这张图可以直观的了解p对决策的影响，p的取值不同会使一个点的最近点集不同。
k值的选择
k值的选择同样会产生较大的影响。所谓k值，就是根据距离量度得出距离该点最近的前k的点。显然，当k=N时只会被归为一类，通常，我们会取一个较小的数值，并使用交叉验证来选取最优的k值。
分类决策规则
k近邻法通常使用多数表决，即由输入实例的k个邻近的训练实例中的多数类决定输入实例的类。
多数表决的规则如下：假设现在的损失函数是0-1损失函数，那么误分类的概率就是：
P ( Y ≠ f ( X ) ) = 1 − P ( Y = f ( X ) ) P(Y \neq f(X)) = 1 - P(Y=f(X)) P(Y=f(X))=1−P(Y=f(X))
对给定的实例 x ∈ X x\in \Chi x∈X，其最近邻的k个训练实例点构成集合 N k ( x ) N_k(x) Nk(x)。如果涵盖**N_k(x)**的取余类别是 c j c_j cj，那么误分类率是：
1 k ∑ x i ∈ N k ( x ) I ( y i ≠ c j ) = 1 − 1 k ∑ x i ∈ N k ( x ) I ( y i = c j ) \frac{1}{k}\sum_{x_i\in N_k(x)}I(y_i \neq c_j) = 1 - \frac{1}{k}\sum_{x_i\in N_k(x)}I(y_i = c_j) k1xi∈Nk(x)∑I(yi=cj)=1−k1xi∈Nk(x)∑I(yi=cj)
显然，如果想降低误分类率，我们要尽可能提高 ∑ x i ∈ N k ( x ) I ( y i = c j ) \sum_{x_i\in N_k(x)}I(y_i = c_j) ∑xi∈Nk(x)I(yi=cj)。因而多数表决规则等价于经验风险最小化。
k近邻法的实现：kd树
与其使用线性的计算来获得距离，建议使用特殊的结构来存储训练数据。kd树就是其中一种。
构造kd树的过程是一个递归的过程，算法如下：
-
输入：k维空间数据集 T = x 1 , x 2 , . . . , x N , T = {x_1,x_2,...,x_N}, T=x1,x2,...,xN,其中 x i = { x i ( 1 ) , x i ( 2 ) , . . . , x i ( k ) } T , i = 1 , 2 , . . . N x_i = \{x_i^{(1)},x_i^{(2)},...,x_i^{(k)}\}^T,i=1,2,...N xi={xi(1),xi(2),...,xi(k)}T,i=1,2,...N
-
输出：kd树
-
开始时构造根节点。选择 x ( 1 ) x^{(1)} x(1)为坐标轴，以T中所有实例的 x ( 1 ) x^{(1)} x(1)坐标的中位数为切分点，将根节点对应的区域分成两个区域。
之后，由根节点生成深度为1的左右自己欸但，分别表示小于切分点的子区域和大于切分点的子区域，并将落在切分超平面上的实例点保存在根节点。
-
递归：对于深度为j的结点，选择 x ( l ) x^{(l)} x(l)为切分的坐标轴，切分，划分…
-
知道两个子区域没有实例时停止。
-
造树并不是目的，我们的最终目的是找结点的最近邻，因而对应的kd树最近邻搜索：
- 输入：已构造的kd树；目标点x；
- 输出：x的最近邻
- 在kd树中找考汉目标点x的叶子结点：从根节点出发，递归的向下访问到kd树。若目标点x当前位的坐标小于切分点的坐标，就坐椅，否则有意，直到子节点。
- 那么该子节点就是x的“当前最近点”
- 递归回退，对每个结点都进行如下操作：
- 如果该节点的实例点比当前最近点距离目标点更近，就医该实例点为“当前最近点
- 当前最近点一定存在于该节点的一个子结点对应的取余。检查该子结点的父结点的另一子结点对应的区域是否有更近的点。具体地，检查另一子结点对应的区域是否与以目标点为球心，到当前最近点距离为半径的超球体相交。如果想叫，移动到另一个子结点，接着递归。否则，向上回退。
- 当回退到根节点时搜索结束。最后的“当前最近点”即为x的最近邻点。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aL6zNgLC-1626781614247)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194256.png?token=AN7NJ7IRYO6FJXPVDI4L3ULA623P2)]
朴素贝叶斯法
说到这个东西，其实是一个非常基础的东西：条件概率。这个东西主要是用于分类的，理解很多简单。
朴素贝叶斯的学习和分类
现在有n个特征的N个数据和K类，我们要做的就是利用训练数据，获得一个联合概率分布，即 P ( X = x ∣ Y = c k ) = P ( X ( 1 ) = x ( 1 ) , . . . , X ( n ) = x ( n ) ∣ Y = c k ) P(X=x|Y=c_k) = P(X^{(1)}=x^{(1)},...,X^{(n)}=x^{(n)}|Y=c_k) P(X=x∣Y=ck)=P(X(1)=x(1),...,X(n)=x(n)∣Y=ck)
这个东西不难理解。那么对于上述如此的数据，到底会有多少个参数（离散概率分布）呢？不妨计算一下，首先y可以分为K类，假设对于每个x，每个维度（属性）都有 S j S_j Sj个取值，呢么参数的个数就是他们相乘： K ∏ j = 1 n S j K\prod_{j=1}^nS_j K∏j=1nSj
当然，我们是学过概率论的，朴素贝叶斯法对条件概率分布做了条件独立性的假设。优点是让这种算法的逻辑十分简单，但是缺点就是，当属性之间存在关系是，分类效果会很差。这是后话。这个假设表示出来长这样： P ( X = x ∣ Y = c k ) = P ( X ( 1 ) = x ( 1 ) , . . . , X ( n ) = x ( n ) ∣ Y = c k ) = ∏ j = 1 n P ( X ( j ) = x ( j ) ∣ Y = c k ) P(X=x|Y=c_k)=P(X^{(1)}=x^{(1)},...,X^{(n)}=x^{(n)}|Y=c_k)=\prod_{j=1}^n P(X^{(j)}=x^{(j)}|Y=c_k) P(X=x∣Y=ck)=P(X(1)=x(1),...,X(n)=x(n)∣Y=ck)=j=1∏nP(X(j)=x(j)∣Y=ck)
在进行统计学习算法的学习时，我们都是根据想要的结果进行算法的推导，对于朴素贝叶斯，器分类器表示为： y = f ( x ) = a r g m a x c k P ( Y = c k ) ∏ j P ( X ( j ) ∣ Y = c k ) ∑ k P ( Y = c k ) ∏ j P ( X ( j ) ∣ Y = c k ) y=f(x)=argmax_{c_k}\frac{P(Y=c_k)\prod_jP(X^{(j)}|Y=c_k)}{\sum_kP(Y=c_k)\prod_jP(X^{(j)}|Y=c_k)} y=f(x)=argmaxck∑kP(Y=ck)∏jP(X(j)∣Y=ck)P(Y=ck)∏jP(X(j)∣Y=ck)
看上去很复杂，实际上是这样的： P ( Y ∣ X ) = P ( Y ) ∏ i = 1 N P ( X i ∣ Y ) P ( X ) P(Y|X) = \frac{P(Y)\prod_{i=1}^NP(X_i|Y)}{P(X)} P(Y∣X)=P(X)P(Y)∏i=1NP(Xi∣Y)
也就是说，我们最后要获得一个概率表，这样理解起来确实不难吧。贝叶斯算法的原理是以比较复杂的推导过程，会写到最后的证明部分。
朴素贝叶斯如何学习
这一部分更为科学的说法是：朴素贝叶斯法的参数估计，实际上就是获得每个离散点的条件概率，这里我们使用最大似然估计法。那么条件概率的最大似然估计是：
P ( X ( j ) = a j l ∣ Y = c k ) = ∑ i = 1 N I ( x i ( j ) = a j l , y i = c k ) ∑ i = 1 N I ( y i = c k ) P(X^{(j)}=a_{jl}|Y=c_k) = \frac{\sum^N_{i=1}I(x_i^{(j)}=a_{jl},y_i=c_k)}{\sum^N_{i=1}I(y_i=c_k)} P(X(j)=ajl∣Y=ck)=∑i=1NI(yi=ck)∑i=1NI(xi(j)=ajl,yi=ck)
但是在计算条件概率的时候，我们还需要使用 Y = c k Y=c_k Y=ck的概率，它的计算方法也十分容易：
P ( Y = c k ) = ∑ i = 1 N I ( y i = c k ) N P(Y=c_k)=\frac{\sum^N_{i=1}I(y_i=c_k)}{N} P(Y=ck)=N∑i=1NI(yi=ck)
之所以这么简单是因为这里的损失为0-1损失函数，更复杂的不多说明，可能也用不到。
那么确定实例x的类：
y = a r g m a x c k P ( Y = c k ) ∏ j = 1 n P ( X ( j ) = x ( j ) ∣ Y = c k ) y = argmax_{c_k}P(Y=c_k)\prod_{j=1}^nP(X^{(j)}=x(j)|Y=c_k) y=argmaxckP(Y=ck)j=1∏nP(X(j)=x(j)∣Y=ck)
贝叶斯估计
显然，上述最大似然估计会出现概率为0的情况，当然，解决方案也很简单——采用贝叶斯估计
P λ ( X ( j ) = a j l ∣ Y = c k ) = ∑ i = 1 N I ( x i ( j ) = a j l , y i = c k ) + λ ∑ i = 1 N I ( y i = c k ) + S j λ P_\lambda(X^{(j)}=a_{jl}|Y=c_k)=\frac{\sum_{i=1}^{N}I(x_i^{(j)}=a_{jl},y_i=c_k)+\lambda}{\sum_{i=1}^NI(y_i=c_k)+S_j\lambda} Pλ(X(j)=ajl∣Y=ck)=∑i=1NI(yi=ck)+Sjλ∑i=1NI(xi(j)=ajl,yi=ck)+λ
至于剩下的内容，就与朴素贝叶斯一样了。
至此，看起来复杂的贝叶斯就算理解了。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KC1Rgcuj-1626781614248)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194516.png?token=AN7NJ7OAOQHCHXK2CO4ANCLA623YU)]
决策树
与朴素贝叶斯相反，这个东西看上去简单，实际上并不简单。通过代码我们可以很容易的生成一棵决策树，但是其实现原理有两个重点：特征的选择和剪枝。
前置任务
为了方便我们后续的理解，先简述一些内容。
决策树模型：是一种树形结构，其实有点类似朴素贝叶斯，但是与之最大的不同是，朴素贝叶斯实际上是解决离散的数据分类，无法解决连续的特征数据分类，二决策树可以通过划分一个范围来解决这个问题。
叶节点，样本点：这两个东西虽然都是模型末端的东西，可以见下图：
在这个图片中，叶节点有三个，但是类别只有两个。在叶节点之下的ABCDEFG即为样本点。还有一点要注意的是，虽然ABCD最后都是百万富翁，但是其判断的路径是不同的。
那么接下来就正式开始。
信息增益
这里涉及到了熵的概念，熵是表示速记变量不确定性的度量，当然，在之前的一篇文章中我较为详细的说明了熵的概念，可以移步到那篇文章。
对于有n个特征数的随机变量X，其熵的定义为：
H ( X ) = − ∑ i = 1 n p i l o g p i H(X) = -\sum^n_{i=1}p_ilogp_i H(X)=−i=1∑npilogpi
由于熵依赖的是X的分布而非X的取值，因而式子其实也可以改为：
H ( p ) = − ∑ i = 1 n p i l o g p i H(p) = -\sum^n_{i=1}p_ilogp_i H(p)=−i=1∑npilogpi
通过上述决策树模型的例子，我们看得出来，CD成为百万富翁，其实是在资金流小于100万的情况下成为百万富翁，所以存在这着一个条件概率。所以有一个条件熵的概率 H ( Y ∣ X ) H(Y|X) H(Y∣X)表示在抑制随机变量X的条件下Y的不确定性，定义为X在给定条件下Y的条件概率分布的熵对X的数学期望（两种表述一个意思）：
H ( Y ∣ X ) = ∑ i = 1 n p i H ( Y ∣ X = x i ) H(Y|X)=\sum_{i=1}^np_iH(Y|X=x_i) H(Y∣X)=i=1∑npiH(Y∣X=xi)
当我们通过数据集得到熵和条件熵时，此时他们称作经验熵和条件经验熵。
决策树生成核心的地方是如何选择特征作为划分的条件，从直觉上来说，我们肯定会选择类别之间差距较大的特征作为顶层的分类条件。事实上，决策树也确实是这样进行决策选择的。那么如何表示“类别之间差距较大的特征”这一东西？我们使用信息增益：
所谓信息增益，就是得知特征X的信息而使得类Y的信息的不确定性减少的程度。现有特征A对训练集的D的信息增益 g ( D , A ) g(D,A) g(D,A)，定义为集合D的经验熵 H ( D ) H(D) H(D)与特征A在给定条件下D的经验条件熵 H ( D ∣ A ) H(D|A) H(D∣A)之差：
g ( D , A ) = H ( D ) − H ( D ∣ A ) g(D,A)=H(D)-H(D|A) g(D,A)=H(D)−H(D∣A)
如何根据数据集进行不同特征的信息增益，如下：
-
设训练数据集为D， ∣ D ∣ |D| ∣D∣表示其样本容量。现设K个类 C k C_k Ck， k = 1 , 2 , . . . , K k=1,2,...,K k=1,2,...,K, ∣ C k ∣ |C_k| ∣Ck∣为属于类 C k C_k Ck的样本个数， ∑ k = 1 K ∣ C k ∣ = ∣ D ∣ \sum_{k=1}^K|C_k| = |D| ∑k=1K∣Ck∣=∣D∣。设A有n个不同的取值 a 1 , a 2 , . . . , a n {a_1,a_2,...,a_n} a1,a2,...,an，根据特征A的取值将D划分为n个子集 D 1 , D 2 , . . . , D n D_1,D_2,...,D_n D1,D2,...,Dn，同样有 ∑ i = 1 n ∣ D i ∣ = ∣ D ∣ \sum_{i=1}^n|D_i|=|D| ∑i=1n∣Di∣=∣D∣记自己 D i D_i Di中属于类 C k C_k Ck的样本的集合为 D i k D_{ik} Dik， ∣ D i k ∣ |D_{ik}| ∣Dik∣那么信息增益分三步计算。
-
首先计算D的经验熵：
H ( D ) = − ∑ k = 1 K ∣ C k ∣ ∣ D ∣ l o g 2 ∣ C k ∣ ∣ D ∣ H(D)=-\sum_{k=1}^K \frac{|C_k|}{|D|}log_2\frac{|C_k|}{|D|} H(D)=−k=1∑K∣D∣∣Ck∣log2∣D∣∣Ck∣
-
其次计算特征A对数据集D的经验条件熵:
H ( D ∣ A ) = ∑ i = 1 n ∣ D i ∣ ∣ D ∣ H ( D i ) H(D|A) = \sum_{i=1}^n\frac{|D_i|}{|D|}H(D_i) H(D∣A)=i=1∑n∣D∣∣Di∣H(Di)
-
最后进行信息增益的计算：
g ( D , A ) = H ( D ) − H ( D ∣ A ) g(D,A)=H(D)-H(D|A) g(D,A)=H(D)−H(D∣A)
信息增益值是相对于训练数据集的，没有绝对意义，分类越困难，信息增益会越大。为了校正，我们可以使用信息增益比：
g R ( D , A ) = g ( D , A ) H ( D ) g_R(D,A) = \frac{g(D,A)}{H(D)} gR(D,A)=H(D)g(D,A)
决策树的生成
如果我们只得到了每一层需要进行分类的特征，那么我们最后得到的实际上会是一个完全二叉树，会将每一个类型都分类，显然这样是没有意义的，也就是说存在一个递归停止的条件：即对分类影响不大的特征，这里叫他阈值。
所以综合上述的内容，我们可以生成一棵决策树。根据特征的信息增益方式不同，决策树的生辰也有不同的算法。
ID3算法是直接使用信息增益进行树生成的算法，当信息增益值大于阈值时，会以此结点为根节点生成两个（或多个）子结点，之后将满足不同子结点条件的样本分配至子结点，若小于阈值，则将其作为根节点。
C4.5算法则是使用信息增益比来进行结点划分的条件，同样也存在一个阈值。由于对其做了D的经验熵的除，不仅进行了归一，同时也可以减弱ID3算法出现过拟合的情况。
就像最开始说的，如果不分配阈值或者阈值分配过小，那么很容易就会生成大量的结点，从而导致过拟合，同时ID3算法只是做差也难得到一个标准，即使时C4.5也存在过拟合的情况。为什么，原因有二，当存在噪声且该噪声被分配到样例数量较小的类别是，该噪声就会为该分支开辟一个新的分支。其次，即使不存在噪声，当较少的样本被分到一个分支时，如果他们中的大部分表现出了惊人的规律，使得一些属性恰巧可以很好地分割样例，同样会出现过拟合。所以总结一下，就是样例较少的分支，容易由于部分数据差别较大而开辟新的分支从而过拟合。
对于为了减少过拟合，使生成树分类效果更加，我们有两种方法：树的剪枝和CART树
树的剪枝
从上文我们知道分支多的树会过拟合，那很简单，我们只需要减去一些会导致过拟合的分支即可，也就是说这是个优化问题，我们需要一个优化函数（在此我们叫他损失函数吧）
我们假设树T的结点个数为 ∣ T ∣ |T| ∣T∣，t是树T的叶结点，该结点有 N t N_t Nt个样本点，其中k类的样本点有 N t k N_{tk} Ntk个， H t ( T ) H_t(T) Ht(T)为叶节点t上的经验熵， α ≥ 0 \alpha\geq0 α≥0为承诺书，那么决策树学习的损失函数为：
C α ( T ) = ∑ t = 1 ∣ T ∣ N t H t ( T ) + α ∣ T ∣ C_\alpha(T)=\sum_{t=1}^{|T|}N_tH_t(T)+\alpha|T| Cα(T)=t=1∑∣T∣NtHt(T)+α∣T∣
我们可以令：
C ( T ) = ∑ t = 1 ∣ T ∣ N t H t ( T ) = − ∑ t = 1 ∣ T ∣ ∑ k = 1 K N t k l o g N t k N t C(T) = \sum_{t=1}^{|T|}N_tH_t(T)=-\sum_{t=1}^{|T|}\sum_{k=1}^KN_{tk}log\frac{N_{tk}}{N_t} C(T)=t=1∑∣T∣NtHt(T)=−t=1∑∣T∣k=1∑KNtklogNtNtk
所以就可以得到：
C α ( T ) = C ( T ) + α ∣ T ∣ C_\alpha(T)=C(T)+\alpha|T| Cα(T)=C(T)+α∣T∣
这个东西有点眼熟是吧，其实它第一次出现在概论里面，就是加了结构风险的损失函数。
既然有了损失函数，我们就要使用一些方法来减小损失函数，算法如下：
- 计算每个结点的经验熵
- 递归的从树的叶结点向上回缩，如果会所之后得到的损失是函数下降，就进行剪枝，直至得到损失函数最小的子树。
CART算法
CART算法叫做分类与回归树，是我们现在使用比较广泛的一种决策树算法，是在给定输入随机变量X条件下输出随机变量Y的条件概率分布的学习方法。假设决策树是二叉树，内部结点的特征取值为“是”和“否”。算法如下：
- 基于数据集生成尽可能大的决策树
- 剪枝
从CART的名字我们可以看出来，其实际上分为两部分，分别为分类树和回归树，分类树的功能就是分类，回归树的功能是拟合，更加细节的内容可以自己查阅相关博文。
决策树的生成就是递归的构建二叉决策树的过程，其中，对于回归树，我们使用平方误差最小化准则，对于分类树，我们使用基尼指数最小化。接下来就是两种树的生成算法和剪枝算法。
回归树的生成算法
回归树最后的结果是一个回归函数，但是由于决策树的性质，实际上得到的结果是有限的。回归树的模型可以表示为：
f ( x ) = ∑ m = 1 M c m I ( x ∈ R m ) f(x)=\sum^M_{m=1}c_mI(x\in R_m) f(x)=m=1∑McmI(x∈Rm)
当划分确定时，我们使用平方误差来表示误差，那么我们很容易得知，单元 R m R_m Rm上的最优值 c ^ m \hat{c}_m c^m就是输入实例 x i x_i xi对应的输出 y i y_i yi的均值。即：
c ^ m = a v e ( y i ∣ x i ∈ R m ) \hat{c}_m=ave(y_i|x_i\in R_m) c^m=ave(yi∣xi∈Rm)
那么该如何进行决策树的划分。这里采用的是启发式的方法，选择第j个变量 x ( j ) x^{(j)} x(j)和它的取值s，作为切分向量和切分点，并定义两个区域： R 1 ( j , s ) = { x ∣ x ( j ) ≤ s } 和 R 2 ( j , s ) = { x ∣ x ( j ) > s } R_1(j,s)=\{x|x^{(j)}\leq s\}和R_2(j,s)=\{x|x^{(j)} > s\} R1(j,s)={x∣x(j)≤s}和R2(j,s)={x∣x(j)>s}
所以使用最小二乘回归树生成的算法：
然后寻找最优切分变量j和最优切分点s，具体的算法如下：
- (1)选择最优切分变量j和切分点s，求解：
m i n j , s [ m i n c 1 ∑ x ∈ R 1 ( j , s ) ( y i − c 1 ) 2 + m i n c 2 ∑ x ∈ R 2 ( j , s ) ( y i − c 2 ) 2 ] min_{j,s}[min_{c_1}\sum_{x\in R_1(j,s)}(y_i-c_1)^2+min_{c_2}\sum_{x\in R_2(j,s)}(y_i-c_2)^2] minj,s[minc1x∈R1(j,s)∑(yi−c1)2+minc2x∈R2(j,s)∑(yi−c2)2]
需要遍历变量j，对固定的划分变量j扫描划分s。
- (2)优选定的对(j,s)划分区域并决定相应的输出值。
R 1 ( j , s ) = { x ∣ x ( j ) ≤ s } 和 R 2 ( j , s ) = { x ∣ x ( j ) > s } R_1(j,s)=\{x|x^{(j)}\leq s\}和R_2(j,s)=\{x|x^{(j)} > s\} R1(j,s)={x∣x(j)≤s}和R2(j,s)={x∣x(j)>s}
c ^ m = 1 N m ∑ x i ∈ R m ( j , s ) y i , x ∈ R m , m = 1 , 2 \hat{c}_m=\frac{1}{N_m}\sum_{x_i\in R_m(j,s)}y_i,x\in R_m,m=1,2 c^m=Nm1xi∈Rm(j,s)∑yi,x∈Rm,m=1,2
-
反复进行上述不走，直至满足停止条件。
-
生成决策树：
f ( x ) = ∑ m = 1 M c m I ( x ∈ R m ) f(x)=\sum^M_{m=1}c_mI(x\in R_m) f(x)=m=1∑McmI(x∈Rm)
分类树的生成
分类树使用基尼指数选择最优特征，同时决定该特征的队友二值切分点。所以我们先了解一下基尼指数是什么：
-
假设有K个类，样本点属于第k类的概率为 p k p_k pk，则概率分布的基尼指数定义为：
G i n i ( p ) = ∑ k = 1 K p k ( 1 − p k ) = 1 − ∑ k = 1 K p k 2 Gini(p) = \sum_{k=1}^Kp_k(1-p_k)=1-\sum_{k=1}^Kp_k^2 Gini(p)=k=1∑Kpk(1−pk)=1−k=1∑Kpk2
所以，对于给定的样本集合D，其基尼指数为：
G i n i ( D ) = 1 − ∑ k = 1 K ( ∣ C k ∣ ∣ D ∣ ) 2 Gini(D)=1-\sum_{k=1}^K(\frac{|C_k|}{|D|})^2 Gini(D)=1−k=1∑K(∣D∣∣Ck∣)2
如果样本集合D根据特征A是否取某一可能值a被分割成 D 1 D_1 D1和 D 2 D_2 D2两部分，即
D 1 = { ( x , y ) ∈ D ∣ A ( x ) = a } ， D 2 = D − D 1 D_1 = \{(x,y)\in D|A(x)=a\}，D_2=D-D_1 D1={(x,y)∈D∣A(x)=a}，D2=D−D1
那么在特征A的情况下，集合D的基尼指数为：
G i n i ( D , A ) = ∣ D 1 ∣ ∣ D ∣ G i n i ( D 1 ) + ∣ D 2 ∣ ∣ D ∣ G i n i ( D 2 ) Gini(D,A) = \frac{|D_1|}{|D|}Gini(D_1)+\frac{|D_2|}{|D|}Gini(D_2) Gini(D,A)=∣D∣∣D1∣Gini(D1)+∣D∣∣D2∣Gini(D2)
从基尼指数关于集合D的公式，我们不难看出其表示的是集合D经A分割后集合D的不确定性，其实是有点类似熵的。
那么二叉决策树的生成方法：
-
计算现有特征对数据集的基尼指数，同时对于每一个特征A，对其可能取的两个值a，根据样本点对A=a的测试分成两部分，并计算A=a时的基尼指数。
-
在上述得到的A特征和切分点中，选择基尼指数最小的特征及其对应切分点作为最优特征与最优切分点。
-
递归的对子结点进行上述的运算，直至满足停止条件。
CART剪枝
从整体树 T 0 T_0 T0开始剪枝，对 T 0 T_0 T0的任意内部结点t，以t为单结点树的损失函数：
C α ( t ) = C ( t ) + α C_\alpha(t)=C(t)+\alpha Cα(t)=C(t)+α
以t为根结点的子树 T t T_t Tt的损失函数为：
C α ( T t ) = C ( T t ) + α ∣ T t ∣ C_\alpha(T_t)=C(T_t)+\alpha|T_t| Cα(Tt)=C(Tt)+α∣Tt∣
显然， α \alpha α充分小时，有不等式：
C α ( T t ) < C α ( t ) C_\alpha(T_t)<C_\alpha(t) Cα(Tt)<Cα(t)
所以我们只要找到某一时刻的 α \alpha α使得式子左右两边相等。
当 α \alpha α继续增大时，我们将式子反向，可以得到 α = C ( t ) − C ( T t ) ∣ T t ∣ − 1 \alpha = \frac{C(t)-C(T_t)}{|T_t|-1} α=∣Tt∣−1C(t)−C(Tt)，此时说明两个树有相同的损失函数值。而t的结点更少，因而取t，对 T t T_t Tt剪枝。
获得不同的子树序列后，我们使用独立的验证序列集（交叉验证法）来选取最优子树。
综上所述，CART的剪枝算法如下：
-
(1)令 α = ∞ \alpha = \infin α=∞, k = 0 k=0 k=0, T = T 0 T=T_0 T=T0
-
(2)计算 C ( T t ) C(T_t) C(Tt), ∣ T t ∣ |T_t| ∣Tt∣以及:
g ( t ) = C ( t ) − C ( T t ) ∣ T t ∣ − 1 g(t) = \frac{C(t)-C(T_t)}{|T_t|-1} g(t)=∣Tt∣−1C(t)−C(Tt)
α = m i n ( α , g ( t ) ) \alpha = min(\alpha,g(t)) α=min(α,g(t))
-
(3)自下而上的访问树的内部节点t。如果有 g ( t ) = α g(t)=\alpha g(t)=α则对其进行剪枝，并对叶节点t以多数表决法决定其类。
-
(4)令k=k+1, α k = α \alpha_k=\alpha αk=α, T k = T T_k=T Tk=T
-
(5)如果T不是根节点组成的树，返回第3步
-
采用交叉烟瘴发在子树序列 T 0 , T 1 , . . . , T n T_0,T_1,...,T_n T0,T1,...,Tn中选取最优子树 T α T_\alpha Tα
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lQ4ThPne-1626781614249)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194534.png?token=AN7NJ7I6ONM6FS4D7ZUPVWTA623ZY)]
逻辑斯谛回归与最大熵模型
在之前的内容，我们了解到了最大熵作为概率模型学习的一个准则。最大熵模型属于对数线性模型，另一个是逻辑斯谛回归模型，这两个内容也是接下来需要讲解的。
逻辑斯谛回归模型
首先，我觉得有必要说明一下为什么又逻辑斯谛回归。第二章的时候我们接触到了感知机，但是感知机十分的弱鸡，只能进行-1和1的选择，两个结果的差距很大，同时感知机的函数在0点处无法微分，基于上述原因，有必要提出逻辑斯蒂芬必得函数。
逻辑斯谛分布的定义如下：设X是连续随机变量，X服从逻辑斯蒂分布是指X具有下列分布函数和密度函数：
F ( x ) = P ( X ≤ x ) = 1 1 + e x − μ / γ F(x)=P(X\leq x)=\frac{1}{1+e^{x-\mu/\gamma}} F(x)=P(X≤x)=1+ex−μ/γ1
f ( x ) = F ′ ( x ) = e − ( x − μ ) / γ γ ( 1 + e − ( x − μ ) / γ ) 2 f(x)=F'(x)=\frac{e^{-(x-\mu)/\gamma}}{\gamma(1+e^{-(x-\mu)/\gamma})^2} f(x)=F′(x)=γ(1+e−(x−μ)/γ)2e−(x−μ)/γ
其中 μ \mu μ为位置参数， γ > 0 \gamma>0 γ>0为形状参数。
接下来看看对应的二项逻辑斯蒂回归模型，作为一种分类模型，我们使用条件概率分布来表示：
P ( Y = 1 ∣ x ) = e x p ( ω ⋅ x + b ) 1 + e x p ( ω ⋅ x + b ) P(Y=1|x)=\frac{exp(\omega \cdot x +b)}{1+exp(\omega \cdot x+b)} P(Y=1∣x)=1+exp(ω⋅x+b)exp(ω⋅x+b)
P ( Y = 0 ∣ x ) = 1 1 + e x p ( ω ⋅ x + b ) P(Y=0|x)=\frac{1}{1+exp(\omega \cdot x+b)} P(Y=0∣x)=1+exp(ω⋅x+b)1
看上去复杂，我们可以这样理解，首先，概率的范围是一个0~1的区间，所以需要归一化，同时其还得有指数的特征，因而就可以得到这个东西。
那么继续，接下来是一个叫做几率的概念，这个东西是指事件发生的概率和该事件不发生的概率的比值，综合上面的两个式子，可以这样推导：
l o g i t ( p ) = l o g p 1 − p = w ⋅ x logit(p)= log\frac{p}{1-p}=w \cdot x logit(p)=log1−pp=w⋅x
综上所述，不难得知，逻辑斯谛回归模型破除了传统的感知机的限制，而是可以扩宽到极大的定义域和值域。我们不难分析出，线性函数 w ⋅ x + b w \cdot x +b w⋅x+b的值越大，条件概率就越接近1（而不是像感知机一样草率的将结果等于1）。
模型参数估计
我们大致得知了模型长什么样，显然接下来就是使用数据来获取较好的模型参数。即参数估计。在此，我们仍然使用（对数）似然函数来进行模型参数的估计。
我们首先设： P ( Y = 1 ∣ x ) = π ( x ) P ( Y = 0 ∣ x ) = 1 − π ( x ) P(Y=1|x)=\pi(x) \space P(Y=0|x)=1- \pi(x) P(Y=1∣x)=π(x) P(Y=0∣x)=1−π(x)
那么对数似然函数就是：
L ( w ) = l o g ( ∏ i = 1 N [ π ( x i ) ] y i [ 1 − π ( x i ) ] 1 − y i ) = ∑ i = 1 N [ y i l o g π ( x i ) + ( 1 − y i ) l o g ( 1 − π ( x i ) ) ] = ∑ i = 1 N [ y i l o g π ( x i ) 1 − π ( x i ) + l o g ( 1 − π ( x i ) ) ] = ∑ i = 1 N [ y i ( w ⋅ x i ) − l o g ( 1 + e x p ( w ⋅ x i ) ] \begin{aligned}L(w)&=log(\prod^N_{i=1}[\pi(x_i)]^{y_i}[1-\pi(x_i)]^{}1-y_i)\\&=\sum^N_{i=1}[y_i log\pi(x_i)+(1-y_i)log(1-\pi(x_i))]\\&=\sum^N_{i=1}[y_ilog\frac{\pi(x_i)}{1-\pi(x_i)}+log(1-\pi(x_i))]\\&=\sum^N_{i=1}[y_i(w \cdot x_i)-log(1+exp(w \cdot x_i)]\end{aligned} L(w)=log(i=1∏N[π(xi)]yi[1−π(xi)]1−yi)=i=1∑N[yilogπ(xi)+(1−yi)log(1−π(xi))]=i=1∑N[yilog1−π(xi)π(xi)+log(1−π(xi))]=i=1∑N[yi(w⋅xi)−log(1+exp(w⋅xi)]
只需要求 L ( w ) L(w) L(w)的最大值即可获得到对应的 w w w的估计值。
多项逻辑斯谛回归模型
这里就稍微提一下。
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(Y=k|x)=\frac{exp(w_k\cdot x)}{1+\sum_{k=1}^{k-1}exp(w_k \cdot x)},k=1,2,..,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(Y=K|x)=\frac{1}{1+\sum_{k=1}^{k-1}exp(w_k \cdot x)} P(Y=K∣x)=1+∑k=1k−1exp(wk⋅x)1
最大熵模型
与逻辑斯谛类似，最大熵模型认为学习概率模型时熵最大的模型是最好的模型。很容易理解，当事件等概率分布的时候熵显然是最大的，也正是因为如此，实际的学习过程中会存在一些约束条件，来限制轻而易举的等可能来实现最大熵。同时，为了转化约束问题为非约束问题，还会使用到拉格朗日乘子法。
通过训练集，我们可以知道每种特征样本的数量占所有样本的比例以及某一类样本占所有样本的体积，即：
P ~ ( X = x , Y = y ) = v ( X = x , Y = y ) N \widetilde{P}(X=x,Y=y)=\frac{v(X=x,Y=y)}{N} P (X=x,Y=y)=Nv(X=x,Y=y)以及 P ~ ( X = x ) = v ( X = x ) N \widetilde{P}(X=x)=\frac{v(X=x)}{N} P (X=x)=Nv(X=x)
在知道上述内容之后，我们就可以得到期望值：
E P ~ ( f ) = ∑ x , y P ~ ( x , y ) f ( x , y ) E_{\widetilde P}(f) = \sum_{x,y}\widetilde{P}(x,y)f(x,y) EP (f)=x,y∑P (x,y)f(x,y)
但我们要得到的是 P ( X ∣ Y ) P(X|Y) P(X∣Y)，因而我们可以得到有关该条件概率的模型：
E P ( f ) = ∑ x , y P ~ ( x ) P ( y ∣ x ) f ( x , y ) E_P(f)=\sum_{x,y}\widetilde P(x)P(y|x)f(x,y) EP(f)=x,y∑P (x)P(y∣x)f(x,y)
按道理说，我们只需要让两个期望值相等即可，事实也确实是这样的，为什么要让两个期望值相等呢？实际上，如果我们已经知道了类别和特征，那么默认均分的情况是熵最大，那么现在给定了数据集，实际上这些数据集就是约束条件，也就是说，上述的两个期望值实际是约束条件。
那么，假设满足所有约束条件的模型集合是：
C = { p ∈ P ∣ E P ( f i ) = E p ~ ( f i ) , i = 1 , 2 , . . . , n } C = \{p\in P | E_P(f_i)=E_{\widetilde {p}}(f_i),i=1,2,...,n\} C={p∈P∣EP(fi)=Ep (fi),i=1,2,...,n}
定义在条件概率分布 P ( Y ∣ X ) P(Y|X) P(Y∣X)上的条件熵为
H ( P ) = − ∑ x , y P ~ ( x ) P ( y ∣ x ) l o g P ( y ∣ x ) H(P)=-\sum_{x,y}\widetilde P(x)P(y|x)logP(y|x) H(P)=−x,y∑P (x)P(y∣x)logP(y∣x)
那么问题就变成了满足约束条件下的最大化 H ( P ) H(P) H(P)问题。
但是我们并不善于解决这种问题，所以我们还是使用拉格朗日乘子法，通过引进拉格朗日乘子 w 0 , w 1 , . . . , w n w_0,w_1,...,w_n w0,w1,...,wn，定义拉格朗日函数：
L ( P , w ) = − H ( P ) + w 0 ( 1 − ∑ y P ( y ∣ x ) ) + ∑ i = 1 n w i ( E P ~ ( f i ) − E P ( f i ) ) L(P,w) = -H(P) + w_0(1-\sum_yP(y|x))+\sum_{i=1}^nw_i(E_{\widetilde P}(f_i)-E_P(f_i)) L(P,w)=−H(P)+w0(1−y∑P(y∣x))+i=1∑nwi(EP (fi)−EP(fi))
我们需要解决的就是：
m a x w m i n P ∈ C L ( P , w ) max_wmin_{P \in C}L(P,w) maxwminP∈CL(P,w)
令其对 P ( y ∣ x ) P(y|x) P(y∣x)的偏导数为0，可以得到
P ( y ∣ x ) = e x p ( ∑ i = 1 n w i f i ( x , y ) ) e x p ( 1 − w 0 ) P(y|x) = \frac{exp(\sum^n_{i=1}w_if_i(x,y))}{exp(1-w_0)} P(y∣x)=exp(1−w0)exp(∑i=1nwifi(x,y))
我们再定义一个规范化因子 Z w ( x ) Z_w(x) Zw(x)，其公式为:
Z w = ∑ y e x p ( ∑ i = 1 n w i f i ( x , y ) ) Z_w = \sum_yexp(\sum_{i=1}^nw_if_i(x,y)) Zw=y∑exp(i=1∑nwifi(x,y))
那么上式就可以化解为：
P w ( y ∣ x ) = 1 Z w ( x ) e x p ( ∑ i = 1 n w i f i ( x , y ) ) P_w(y|x) = \frac{1}{Z_w(x)}exp(\sum_{i=1}^nw_if_i(x,y)) Pw(y∣x)=Zw(x)1exp(i=1∑nwifi(x,y))
所以我们现在只需要最大化上式即可，可是问题来了，这个参数应该怎么学习？
这里就要提到两种方法：改进的迭代尺度法和拟牛顿法。
这两种方法在此不多说明，有兴趣的可以看看这篇博文：https://zhuanlan.zhihu.com/p/43727726
支持向量机
不得不说，这是一种非常厉害的方法，但同时难度也较为大。其思想是这样的，对于一个平面数据，假设其不能被线性可分，那么就没办法了吗？SVM提供了一个升维的方法，将平面数据映射到三维乃至更高维，则必然存在一个维度有超平面可以将两者完全分开。
一些证明
Novikoff定理及证明
-
存在满足条件的的 ∣ ∣ ω ^ o p t ∣ ∣ = 1 ||\hat{\omega}_{opt}||=1 ∣∣ω^opt∣∣=1的超平面 ω ^ o p t ⋅ x ^ = ω o p t ⋅ x + b o p t = 0 \hat{\omega}_{opt} \cdot \hat{x} = \omega_{opt} \cdot x +b_{opt}=0 ω^opt⋅x^=ωopt⋅x+bopt=0将训练数据集完全正确分开；且存在 γ > 0 \gamma >0 γ>0，对所有的 i = 1 , 2 , . . . , N i=1,2,...,N i=1,2,...,N
y i ( ω ^ o p t ⋅ x ^ ) = y i ( ω o p t ⋅ x + b o p t ) ≥ γ y_i(\hat{\omega}_{opt} \cdot \hat{x}) =y_i( \omega_{opt} \cdot x +b_{opt})\geq \gamma yi(ω^opt⋅x^)=yi(ωopt⋅x+bopt)≥γ
-
令 R = m a x 1 ≤ i ≤ N ∣ ∣ x ^ i ∣ ∣ R=max_{1\leq i\leq N}||\hat{x}_i|| R=max1≤i≤N∣∣x^i∣∣，则感知机算法在训练集上无分类次数k满足不等式：
k ≤ ( R γ ) 2 k \leq (\frac{R}{\gamma})^2 k≤(γR)2
（1）由于训练集是线性可分的，所以存在一个超平面能够将两者完全正确分开。所以取此超平面为 ω ^ o p t ⋅ x ^ = ω o p t ⋅ x + b o p t = 0 \hat{\omega}_{opt} \cdot \hat{x} = \omega_{opt} \cdot x +b_{opt}=0 ω^opt⋅x^=ωopt⋅x+bopt=0，使 ∣ ∣ ω ^ o p t ∣ ∣ = 1 ||\hat{\omega}_{opt}||=1 ∣∣ω^opt∣∣=1，那么对于 i = 1 , 2 , . . . , N i =1,2,...,N i=1,2,...,N，均有：
y i ( ω ^ o p t ⋅ x ^ ) = y i ( ω o p t ⋅ x + b o p t ) > 0 y_i(\hat{\omega}_{opt} \cdot \hat{x}) =y_i( \omega_{opt} \cdot x +b_{opt})>0 yi(ω^opt⋅x^)=yi(ωopt⋅x+bopt)>0
所以存在一个 γ \gamma γ，有
γ = min i { y i ( ω ^ o p t ⋅ x ^ ) } \gamma = \min_i\{y_i(\hat{\omega}_{opt} \cdot \hat{x})\} γ=imin{yi(ω^opt⋅x^)}
使 y i ( ω ^ o p t ⋅ x ^ ) = y i ( ω o p t ⋅ x + b o p t ) ≥ γ y_i(\hat{\omega}_{opt} \cdot \hat{x}) =y_i( \omega_{opt} \cdot x +b_{opt})\geq \gamma yi(ω^opt⋅x^)=yi(ωopt⋅x+bopt)≥γ
（2）感知机算法是从 ω ^ 0 = 0 \hat{\omega}_0 = 0 ω^0=0开始，出现误分类时进行权重的更新。我们令 ω ^ k − 1 \hat{\omega}_{k-1} ω^k−1是第k个误分类实例。若 ( x i , y i ) (x_i,y_i) (xi,yi)是被 ω ^ k − 1 \hat{\omega}_{k-1} ω^k−1误分类的数据，那么参数的更新：
ω k ← ω k − 1 + η y i x i \omega_k \leftarrow \omega_{k-1}+\eta y_ix_i ωk←ωk−1+ηyixi
b k ← b k − 1 + η y i b_k \leftarrow b_{k-1}+\eta y_i bk←bk−1+ηyi
即 ω ^ k = ω ^ k − 1 + η y i x ^ i \hat{\omega}_k = \hat{\omega}_{k-1}+\eta y_i \hat{x}_i ω^k=ω^k−1+ηyix^i
接下来推导两个不等式：
-
ω ^ k ⋅ ω ^ o p t = ω ^ k − 1 ⋅ ω ^ o p t + η y i ω ^ o p t ⋅ x ^ i ≥ ω ^ k − 1 ⋅ ω ^ o p t + η γ \hat{\omega}_k \cdot \hat{\omega}_{opt} = \hat{\omega}_{k-1}\cdot \hat{\omega}_{opt}+\eta y_i\hat{\omega}_{opt} \cdot \hat{x}_i\geq\hat{\omega}_{k-1}\cdot \hat{\omega}_{opt} +\eta \gamma ω^k⋅ω^opt=ω^k−1⋅ω^opt+ηyiω^opt⋅x^i≥ω^k−1⋅ω^opt+ηγ
递推之，最后可得：
ω ^ k ⋅ ω ^ o p t ≥ k η γ \hat{\omega}_k \cdot \hat{\omega}_{opt} \geq k\eta \gamma ω^k⋅ω^opt≥kηγ
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hIdrOj1y-1626781614250)(https://raw.githubusercontent.com/bear-zd/tubed/main/20210720194552.png?token=AN7NJ7NY5LPK4GMBW2AGJDDA62324)]
定理证明，误分类的次数k是有上界的，所以感知机学习算法的迭代是收敛的。
后验概率最大化的含义
我们假设选择0-1损失函数那么期望风险函数： R e x p ( f ) = E [ L ( Y , f ( X ) ) ] R_{exp}(f) = E[L(Y,f(X))] Rexp(f)=E[L(Y,f(X))]
取条件期望： R e x p ( f ) = E X ∑ k = 1 K [ L ( c k , f ( X ) ) ] P ( c k ∣ X ) R_{exp}(f) = E_X\sum^{K}_{k=1}[L(c_k,f(X))]P(c_k|X) Rexp(f)=EXk=1∑K[L(ck,f(X))]P(ck∣X)
为了使期望风险最小化，只需对X=x逐个极小化，由此得到：
f ( x ) = a r g m i n y ∈ Y ∑ k = 1 K L ( k k , y ) P ( c k ∣ X = x ) = a r g m i n y ∈ Y ∑ k = 1 K P ( y ≠ c k ∣ X = x ) = a r g m i n y ∈ Y ( 1 − P ( y = c k ∣ X = x ) ) = a r g m a x y ∈ Y P ( y = c k ∣ X = x ) \begin{aligned}f(x)&=argmin_{y\in Y}\sum_{k=1}^KL(k_k,y)P(c_k|X=x)\\ &=argmin_{y\in Y}\sum_{k=1}^KP(y\neq c_k|X=x)\\&=argmin_{y\in Y}(1-P(y=c_k|X=x))\\ &=argmax{_y\in Y}P(y=c_k |X=x)\end{aligned} f(x)=argminy∈Yk=1∑KL(kk,y)P(ck∣X=x)=argminy∈Yk=1∑KP(y=ck∣X=x)=argminy∈Y(1−P(y=ck∣X=x))=argmaxy∈YP(y=ck∣X=x)
所以根据期望风险最小化得到了后验概率最大化准则。这就是朴素贝叶斯的原理。
扫一扫
788
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
