第 3 章 k k k 近邻法
3.1 k k k 近邻算法
k k k 近邻,(K-Nearest-Neighbour ( k k k-NN),是一种基本的分类与回归方法。顾名思义,就是说如果考虑要一个新的实例时,则根据它最近的 k k k 个邻居来判断即可。这k个类的多数属于哪个类,新实例就是哪个类(近朱者赤,近墨者黑)
主要思想:假定给定一个训练数据集,其中实例标签已定,当输入新的实例时,可以根据其最近的 k 个训练实例的标签,预测新实例的标签。
分类问题:对新的实例,根据与之相邻的
k
k
k 个训练实例的类别,通过多数表决等方式进行预测。
回归问题:对新的实例,根据与之相邻的
k
k
k 个训练实例的标签,通过均值计算进行预测。
k
k
k 近邻算法:
输入:训练数据集
T
=
{
(
x
1
,
y
1
)
,
(
x
2
,
y
2
)
,
⋯
,
(
x
N
,
y
N
)
}
T = \left\{ \left( x_{1}, y_{1} \right), \left( x_{2}, y_{2} \right), \cdots, \left( x_{N}, y_{N} \right) \right\}
T={(x1,y1),(x2,y2),⋯,(xN,yN)}其中
x
i
∈
X
⊆
R
n
x_{i} \in \mathcal{X} \subseteq R^{n}
xi∈X⊆Rn 为实例的特征向量,$ y_{i} \in \mathcal{Y} = \left{ c_{1}, c_{2}, \cdots, c_{K} \right}$ 是实例的类别,$ i = 1, 2, \cdots, N$;
实例特征向量
x
x
x 。
输出:实例
x
x
x 所属的类
y
y
y
- 根据给定的距离度量,在训练集 T T T 中找出与 x x x 最近的 k k k 个点,涵盖这 k k k 点的 x x x 的邻域记作 N k ( x ) N_{k} \left( x \right) Nk(x);包含两步(计算 x x x 与 T T T 中点的距离、找到最近的 k k k 个点)
- 在
N
k
(
x
)
N_{k} \left( x \right)
Nk(x) 中根据分类决策规则(如多数表决)决定
x
x
x 的类别
y
y
y:
y = arg max c j ∑ x i ∈ N k ( x ) I ( y i = c j ) , i = 1 , 2 , ⋯ , N , j = 1 , 2 , ⋯ , K \begin{aligned} \\ & y = \arg \max_{c_{j}} \sum_{x_{i} \in N_{k} \left( x \right)} I \left( y_{i} = c_{j} \right), \quad i=1,2, \cdots, N, j=1,2,\cdots,K \end{aligned} y=argcjmaxxi∈Nk(x)∑I(yi=cj),i=1,2,⋯,N,j=1,2,⋯,K
式 (3.1) 中 I I I 为指示函数,即当 y i = c j y_i=c_j yi=cj 时 I I I 为 1,否则 I I I 为 0 ■ \quad\quad\blacksquare ■
k k k 近邻法的特殊情况是 k = 1 k=1 k=1 的情形,称为最近邻算法
3,2 k k k 近邻模型
由于 k k k 近邻法就是要找到目标点的 k k k 个邻居,然后依据 k k k 个邻居的类别决策,所以怎么找邻居,找多少个邻居,以及找到邻居后怎么办。
- 距离度量
- k k k 值的选择
- 分类决策规则
当上述三条确定后,每输入一个实例,它所属的类就被唯一确定了,这就相当于根据上述要素将特征空间划分为为一些子空间。
特征空间中,对每个训练实例点
x
i
x_i
xi,距离该点比其他点更近的所有点组成一个区域,叫作单元 (单元)。每个训练实例点拥有一个单元,所有训练实例点的单元构成对特征空间的一个划分。最近邻法将实例
x
i
x_i
xi 的类
y
i
y_i
yi 作为其单元中所有点的类标记(类标签)。这样,每个单元的实例点的类别是确定的。图3.1是二维特征空间划分的一个例子。
距离度量
特征空间中两个实例点的距离是两个实例点相似程度的反映。
k
k
k 近邻模型的特征空间一般是
n
n
n 维实数向量空间
R
n
\mathclose{R}^n
Rn。使用的距离是欧氏距离,但也可以是其他距离,如更一般的
L
p
L_p
Lp 距离或 Minkowski 距离。
p
=
∞
p=\infty
p=∞ 时:
L
∞
(
x
1
,
x
2
)
=
max
{
∣
1
−
5
∣
,
∣
1
−
1
∣
}
=
4
L_{\infty}(x_1,x_2)=\max\{|1-5|,|1-1|\}=4
L∞(x1,x2)=max{∣1−5∣,∣1−1∣}=4;
L
∞
(
x
1
,
x
3
)
=
max
{
∣
1
−
4
∣
,
∣
1
−
4
∣
}
=
3
L_{\infty}(x_1,x_3)=\max\{|1-4|,|1-4|\}=3
L∞(x1,x3)=max{∣1−4∣,∣1−4∣}=3.
不同的距离度量,所确定的最近邻点是不同的
k k k 值的选择
k k k 值的选择会对 k k k 近邻法的结果产生重大影响。
如图所示,有两类不同的样本数据,分别用正方形和三角形表示,绿色的圆所标示的数据则是待分类的数据。怎么给这个绿色的圆分类。
- 如果K=3,绿色圆点的最近的3个邻居是2个红色小三角形和1个蓝色小正方形,多数表决,判定绿色的这个待分类点属于红色的三角形一类。
- 如果K=5,绿色圆点的最近的5个邻居是2个红色三角形和3个蓝色的正方形,多数表决,判定绿色的这个待分类点属于蓝色的正方形一类。
如果选择较小的 k k k 值,就相当于用较小的邻域中的训练实例进行预测,
- “学习”的近似误差(approximation error)会减小,只有与输入实例较近的(相似的)训练实例才会对预测结果起作用。
- 缺点是“学习”的估计误差(estimation error)会增大,预测结果会对近邻的实例点非常敏感 [2]。如果邻近的实例点恰巧是噪声,预测就会出错。换句话说,k 值的减小就意味着整体模型变得复杂,容易发生过拟合。
如果选择较大的 k k k 值,就相当于用较大邻域中的训练实例进行预测。
- 优点是可以减少学习的估计误差
- 缺点是学习的近似误差会增大。这时与输入实例较远的(不相似的)训练实例也会对预测起作用,使预测发生错误。 k k k 值的增大就意味着整体的模型变得简单。
近似误差:对现有训练集的训练误差。
估计误差:在测试集上的测试误差。
当训练误差越小时,近似误差就会越小,这种情况下可能发生了过拟合。
当估计误差小时,说明在测试集上,估计值与真实值的差距较小,说明模型具有较强的泛化能力,接近最佳模型。
如果 k = N k=N k=N,那么无论输入实例是什么,都将简单地预测它属于在训练实例中最多的类。这时,模型过于简单,完全忽略训练实例中的大量有用信息,是不可取的。在应用中, k k k 值一般取一个比较小的数值。通常采用交叉验证法来选取最优的k值。
分类决策规则
k
k
k 近邻法中的分类决策规则往往是多数表决:由输入实例的
k
k
k 个邻近的训练实例中的多数类决定输入实例的类。
所以需要一个将实例映射成类别的分类函数。为了制定一个规则,决定这个分类函数,我们需要比较损失情况,由于是分类问题,只有分类是否正确,这时候最常用的损失函数是:0-1 损失函数
L
(
Y
,
f
(
X
)
)
=
{
1
,
Y
≠
f
(
X
)
0
,
Y
=
f
(
X
)
L(Y,f(X))=\left\{\begin{aligned} 1,~~~~~&Y\neq f(X)\\ 0,~~~~~&Y=f(X) \end{aligned} \right.
L(Y,f(X))={1, 0, Y=f(X)Y=f(X)
则
0
−
1
0-1
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\mathcal{X}
x∈X,相应的邻域
N
k
(
x
)
N_k(x)
Nk(x),在
N
k
(
x
)
N_k(x)
Nk(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), 要找到误分类率最小的类别就等价于
arg max
c
j
∑
x
i
∈
N
k
(
x
)
I
(
y
i
=
c
j
)
.
\argmax_{c_{j}} \sum_{x_{i} \in N_{k} \left( x \right)} I \left( y_{i} = c_{j} \right).
cjargmaxxi∈Nk(x)∑I(yi=cj).
3.3 k k k 近邻法的实现: k d kd kd 树
假如我们现在有一个数据集,当给定一个新的实例时,最简单粗暴的办法就是计算它和所有点的距离,然后找到
k
k
k 个最近邻,最后根据多数表决的规则判断这个实例所属的类。
但是如果这个数据集中的训练实例非常多且密集, 并且一个实例也有很多的特征(维数很高),那么每次的计算量都会很大,明显不可取,这时候就需要使用一些特殊的数据结构来帮助新的实例快速找到最近的邻居。具体的方法有很多,下面主要介绍
k
d
kd
kd 树方法。
k d kd kd 树是一种对 k k k 维空间中的实例点进行存储以便对其进行快速检索的树形结构,本质上是种二叉树结构。 根据这个结构对 k k k 维空间进行不断的划分,构造 k d kd kd 树相当于不断地用垂直于坐标轴的超平面将 k k k 维空间切分,构成一系列的 k k k 维超矩形区域。 k d kd kd 树的每个结点对应于一个 k k k 维超矩形区域。
注:这里的 k k k 表示的是实例的维数,不是最近邻的个数
构造 k d kd kd 树的方法如下:构造根结点,使根结点对应于 k k k 维空间中包含所有实例点的超矩形区域;通过下面的递归方法,不断地对 k k k 维空间进行切分,生成子结点在超矩形区域(结点)上选择一个坐标轴和在此坐标轴上的一个切分点,确定一个超平面,这个超平面通过选定的切分点并垂直于选定的坐标轴,将当前超矩形区域切分为左右两个子区域(子结点):这时,实例被分到两个子区域。这个过程直到子区域内没有实例时终止(终止时的结点为叶结点)。在此过程中,将实例保存在相应的结点上。
通常,依次选择坐标轴对空间切分,选择训练实例点在选定坐标轴上的中位数为切分点,这样得到的 k d kd kd 树是平衡的。注意,平衡的 k d kd kd 树搜索时的效率未必是最优的。
平衡
k
d
kd
kd 树构造算法:
输入:
k
k
k维空间数据集
T
=
{
x
1
,
x
2
,
⋯
,
x
N
}
T = \left\{ x_{1}, x_{2}, \cdots, x_{N} \right\}
T={x1,x2,⋯,xN},其中
x
i
=
(
x
i
(
1
)
,
x
i
(
1
)
,
⋯
,
x
i
(
k
)
)
T
x_{i} = \left( x_{i}^{\left(1\right)}, x_{i}^{\left(1\right)},\cdots,x_{i}^{\left(k\right)} \right)^{T}
xi=(xi(1),xi(1),⋯,xi(k))T,
i
=
1
,
2
,
⋯
,
N
i = 1, 2, \cdots, N
i=1,2,⋯,N;
输出:
k
d
kd
kd 树
- 开始:构造根结点,根结点对应于包涵
T
T
T 的
k
k
k 维空间的超矩形区域。
选择 x ( 1 ) x^{\left( 1 \right)} x(1) 为坐标轴,以 T T T 中所欲实例的 x ( 1 ) x^{\left( 1 \right)} x(1) 标的中位数为切分点,将根结点对应的超矩形区域切分成两个子区域。切分由通过切分点并与坐标轴 x ( 1 ) x^{\left( 1 \right)} x(1) 垂直的超平面实现。
由根结点生成深度为1的左、右子结点:坐子结点对应坐标 x ( 1 ) x^{\left( 1 \right)} x(1) 小于切分点的子区域,右子结点对应于坐标 x ( 1 ) x^{\left( 1 \right)} x(1) 大于切分点的子区域。将落在切分超平面上的实例点保存在根结点。 - 重复:对深度为
j
j
j 的结点,选择
x
(
l
)
x^{\left( l \right)}
x(l)为切分坐标轴,$l = j \left(\bmod ~k \right) + 1 $,以该结点的区域中所由实例的
x
(
l
)
x^{\left( l \right)}
x(l) 坐标的中位数为切分点,将该结点对应的超矩形区域切分为两个子区域。切分由通过切分点并与坐标轴
x
(
l
)
x^{\left( l \right)}
x(l) 垂直的超平面实现。
由该结点生成深度为 j + 1 j+1 j+1 的左、右子结点:左子结点对应坐标 x ( l ) x^{\left( l \right)} x(l) 小于切分点的子区域,右子结点对应于坐标 x ( l ) x^{\left( l \right)} x(l) 大于分点的子区域。将落在切分超平面上的实例点保存在该结点。 - 直到两个子区域没有实例存在时停止,从而形成 k d kd kd 树的划分。
例:
T
=
{
(
2
,
3
)
T
,
(
5
,
4
)
T
,
(
9
,
6
)
T
,
(
4
,
7
)
T
,
(
8
,
1
)
T
,
(
7
,
2
)
T
}
T=\{(2,3)^T,(5,4)^T,(9,6)^T,(4,7)^T,(8,1)^T,(7,2)^T\}
T={(2,3)T,(5,4)T,(9,6)T,(4,7)T,(8,1)T,(7,2)T}
因为该训练数据集的维度为 2,那么任选一个特征即可。不妨选择 为
x
(
1
)
x^{(1)}
x(1) 坐标轴,将
x
(
1
)
x^{(1)}
x(1) 中的数据按照从小到大排序,分别是:{2,4,5,7,8,9}。中位数不妨选 7 ,即以
(
7
,
2
)
(7,2)
(7,2) 为根节点,切分整个区域。左边的就是小于 7 的子节点,右边的是大于 7 的子节点。
再次划分区域:
对第一个特征加 1,即以
x
(
2
)
x^{(2)}
x(2) 为坐标轴。对于第一次切分后的左边区域而言,将
x
(
2
)
x^{(2)}
x(2) 中的数据按照从小到大排序,分别是:
{
2
,
3
,
4
,
7
}
\{2,3,4,7\}
{2,3,4,7},中位数为 4 ,切分点坐标为
(
5
,
4
)
(5,4)
(5,4),再画一条横线进行第二次切分。同样地,对第一次切分后的右边区域而言,将
x
(
2
)
x^{(2)}
x(2) 中的数据按照从小到大排序,分别是:
{
1
,
6
}
\{1,6\}
{1,6}因为只有两个点,不妨选择 6 作为切分点,右边区域切分点坐标为
(
9
,
6
)
(9,6)
(9,6) ,画一条横线进行第二次切分。
第二个特征,深度为 2 ,
2
(
m
o
d
2
)
+
1
=
1
2 (\bmod ~2 ) + 1=1
2(mod 2)+1=1 即以
x
(
1
)
x^{(1)}
x(1) 为坐标轴,以此类推会得到
对应的
k
d
kd
kd 树为:
k
d
kd
kd 树构造好了,怎么用它进行快速搜索呢?我们以最近邻
k
d
kd
kd 树搜索为例
kd树的最近邻搜索算法:
输入:
k
d
kd
kd 树;目标点
x
x
x
输出:
x
x
x 的最近邻
- 在 k d kd kd 树中找出包含目标点 x x x 的叶结点:从跟结点出发,递归地向下访问 k d kd kd 树。若目标点 x x x 当前维的坐标小于切分点的坐标,则移动到左子结点,否则移动到右子结点。直到子结点为叶结点为止。
- 以此叶结点为“当前最近点”。
- 递归地向上回退,在每个结点进行以下操作:
3.1 如果该结点保存的实例点比当前最近点距离目标点更近,则以该实例点为“当前最近点”。
3.2 当前最近点一定存在于该结点一个子结点对应的区域。检查该子结点的父结点的另一子结点对应的区域是否有更近的点。具体地,检查另一子结点对应的区域是否与以目标点为球心、以目标点与“当前最近点”间的距离为半径的超球体相交。
如果相交,可能在另一个子结点对应的区域内存在距目标点更近的点,移动到另一个子结点。接着,递归地进行最近邻搜索;
如果不相交,向上回退。 - 当回退到根结点时,搜索结束。最后的“当前最近点”即为 x x x 的当前最近邻点。
我们以刚刚的例子来简要说明一下:
输入:
k
d
kd
kd 树,目标点
(
2
,
4.5
)
(2,4.5)
(2,4.5)
输出: 最近邻点
- 寻找当前最近点:从根节点开始, x = ( 2 , 4.5 ) x=(2,4.5) x=(2,4.5) 在根节点 ( 7 , 2 ) (7,2) (7,2) 的左子区域内,继续到 ( 5 , 4 ) (5,4) (5,4) 所确定的上(左)子区域内,继续到 ( 4 , 7 ) (4,7) (4,7) 的左子区域中, ( 4 , 7 ) (4,7) (4,7) 就是当前最近邻点。
- 回溯:我们以 ( 2 , 4.5 ) (2,4.5) (2,4.5) 为圆心,以 ( 2 , 4.5 ) (2,4.5) (2,4.5) 到 ( 4 , 7 ) (4,7) (4,7) 两点之间的距离为半径画一个圆,这个区域内有两个节点,分别是 ( 2 , 3 ) (2,3) (2,3) 和 ( 5 , 4 ) (5,4) (5,4) ,通过计算 ( 2 , 4.5 ) (2,4.5) (2,4.5) 到这两点的距离,得出到 ( 2 , 3 ) (2,3) (2,3) 的距离最近,那么 ( 2 , 3 ) (2,3) (2,3) 就是最近邻点。
- 接着,再以 ( 2 , 4.5 ) (2,4.5) (2,4.5) 为圆心,以 ( 2 , 4.5 ) (2,4.5) (2,4.5) 到 ( 2 , 3 ) (2,3) (2,3) 两点之间的距离为半径画一个圆,此时圆里没有其他的节点,说明可以确认 ( 2 , 3 ) (2,3) (2,3) 就是当前 ( 2 , 4.5 ) (2,4.5) (2,4.5) 的最近邻点。
- 此时再回到父结点 ( 5 , 4 ) (5,4) (5,4) ,发现这个圆与 ( 5 , 4 ) (5,4) (5,4) 的上(左)结点有交集,但是没有比 ( 2 , 3 ) (2,3) (2,3) 更近的结点,说明 ( 2 , 3 ) (2,3) (2,3) 就是当前 ( 2 , 4.5 ) (2,4.5) (2,4.5) 的最近邻点;再退回至根结点,发现当前的圆与根结点的右子结点没有交集,即 ( 2 , 3 ) (2,3) (2,3) 就是 ( 2 , 4.5 ) (2,4.5) (2,4.5) 的最近邻点。
注:从上述过程也可以看出 k k k 近邻法没有显示的学习过程(训练过程) 因此也被称为 Lazy Learning.
总结
1.
k
k
k 近邻法是基本且简单的分类与回归方法。
k
k
k 近邻法的基本做法是:对给定的训练实例点和输入实例点,首先确定输入实例点的
k
k
k 个最近邻训练实例点,然后利用这
k
k
k 个训练实例点的类的多数来预测输入实例点的类。
2.
k
k
k 近邻模型对应于基于训练数据集对特征空间的一个划分。
k
k
k 近邻法中,当训练集、距离度量、
k
k
k 值及分类决策规则确定后,其结果唯一确定
3.
k
k
k 近邻法三要素:距离度量、
k
k
k 值的选择和分类决策规则。常用的距离度量是欧氏距离及更一般的
L
p
L_p
Lp 距离。
k
k
k 值小时, 近邻模型更复杂;
k
k
k 值大时,
k
k
k 近邻模型更简单。
k
k
k 值的选择反映了对近似误差与估计误差之间的权衡,通常由交叉验证选择最优的
k
k
k。常用的分类决策规则是多数表决,对应于经验风险最小化。
4.
k
k
k 近邻法的实现需要考虑如何快速搜索
k
k
k 个最近邻点。
k
d
kd
kd 是一种便于对k维空间中的数据进行快速检索的数据结构。
k
d
kd
kd 树是二叉树,表示对
k
k
k 维空间的一个划分,其每个结点对应于
k
k
k 维空间划分中的一个超矩形区域。利用
k
d
kd
kd 树可以省去对大部分数据点的搜索,从而减少搜索的计算量。
K-近邻算法在使用的时候相当于一边训练一边测试,所以每一个测试都需要一次训练,这就导致如果数据量特别大的情况下,与其他算法相比会花费大量的时间并且会占用大量的内存进行运算,同时,在计算每个数据的距离值时,会消耗大量的时间,所以该算法更多适用于小数据量的样本进行计算。
优点:简单、易于理解、易于实现、无需估计参数、无需提前训练。
缺点:懒惰算法、对测试样本分类时的计算量大、内存开销大,并且必须指定K值,K值选择不当则分类精度不能保证。
贝叶斯误差率
贝叶斯误差(bayes error rate)是指在现有特征集上,任意可以基于特征输入进行随机输出的分类器所能达到最小误差。也可以叫做最小误差。假设
c
∗
c^*
c∗ 是实例
x
x
x 的真实类别
P
∗
=
P
(
a
≠
c
∗
∣
x
)
=
1
−
P
(
a
=
c
∗
∣
x
)
=
min
c
j
{
1
−
P
(
a
=
c
j
∣
x
)
}
=
1
−
max
c
j
P
(
a
=
c
j
∣
x
)
P^*=P(a\neq c^*|x)=1-P(a=c^*|x)=\min_{c_j}\{1-P(a=c_j|x)\}=1-\max_{c_j}P(a=c_j|x)
P∗=P(a=c∗∣x)=1−P(a=c∗∣x)=cjmin{1−P(a=cj∣x)}=1−cjmaxP(a=cj∣x) 从预先知道的真实分布
P
(
x
,
y
)
P(x,y)
P(x,y) 预测而出现的误差被称为贝叶斯误差
最近邻法的误差率
在上述情况下,考虑最近邻法的误差率,即对于新的实例
x
x
x ,假设
x
i
x_i
xi 是离
x
x
x 最近的训练实例,两者类别分别记作
a
a
a 和
b
b
b,样本独立同分布。
误差率计算:
E
r
r
(
x
,
x
i
)
=
P
(
a
≠
b
∣
x
,
x
i
)
=
∑
j
=
1
K
P
(
a
=
c
j
,
b
≠
c
j
∣
x
,
x
i
)
=
∑
j
=
1
K
P
(
a
=
c
j
∣
x
)
P
(
b
≠
c
j
∣
x
i
)
=
∑
j
=
1
K
P
(
a
=
c
j
∣
x
)
(
1
−
P
(
b
=
c
j
∣
x
i
)
)
\begin{aligned}&Err(x,x_i)=P(a\neq b|x,x_i)=\sum_{j=1}^{K}P(a=c_j,b\neq c_j|x,x_i)\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =\sum_{j=1}^{K}P(a=c_j|x)P(b\neq c_j|x_i)\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =\sum_{j=1}^{K}P(a=c_j|x)(1-P(b = c_j|x_i)) \end{aligned}
Err(x,xi)=P(a=b∣x,xi)=j=1∑KP(a=cj,b=cj∣x,xi) =j=1∑KP(a=cj∣x)P(b=cj∣xi) =j=1∑KP(a=cj∣x)(1−P(b=cj∣xi))
- 当
K
→
∞
K\rightarrow\infty
K→∞ 时,
lim
K
→
∞
P
(
b
=
c
j
∣
x
i
)
=
P
(
a
=
c
j
∣
x
)
\lim\limits_{K\rightarrow\infty}P(b = c_j|x_i)=P(a = c_j|x)
K→∞limP(b=cj∣xi)=P(a=cj∣x)
所以当 K → ∞ K\rightarrow\infty K→∞ 时,
lim K → ∞ E r r ( x , x i ) = lim K → ∞ ∑ j = 1 K P ( a = c j ∣ x ) ( 1 − P ( b = c j ∣ x i ) ) = ∑ c j P ( a = c j ∣ x ) − ∑ c j P 2 ( a = c j ∣ x ) = 1 − ∑ c j P 2 ( a = c j ∣ x ) \begin{aligned}&\lim\limits_{K\rightarrow\infty}Err(x,x_i) =\lim\limits_{K\rightarrow\infty}\sum_{j=1}^{K}P(a=c_j|x)(1-P(b = c_j|x_i))\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =\sum_{c_j}P(a=c_j|x)-\sum_{c_j}P^2(a = c_j|x)\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =1-\sum_{c_j}P^2(a = c_j|x)\end{aligned} K→∞limErr(x,xi)=K→∞limj=1∑KP(a=cj∣x)(1−P(b=cj∣xi)) =cj∑P(a=cj∣x)−cj∑P2(a=cj∣x) =1−cj∑P2(a=cj∣x)
若 x x x 的真实类别为 c ∗ c^* c∗, c ∗ = arg max c j P ( a = c j ∣ x ) c^*=\argmax_{c_j}P(a=c_j|x) c∗=cjargmaxP(a=cj∣x)那么对应的贝叶斯误差率为
P ∗ = P ( a ≠ c ∗ ∣ x ) = 1 − P ( a = c ∗ ∣ x ) P^*=P(a\neq c^*|x)=1-P(a=c^*|x) P∗=P(a=c∗∣x)=1−P(a=c∗∣x) 则误差率可以表示为
lim K → ∞ E r r ( x , x i ) = 1 − ∑ c j P 2 ( a = c j ∣ x ) = 1 − ( P 2 ( a = c ∗ ∣ x ) + ∑ c j ≠ c ∗ P 2 ( a = c j ∣ x ) ) ≤ 1 − P 2 ( a = c ∗ ∣ x ) = ( 1 + P ( a = c ∗ ∣ x ) ) ( 1 − P ( a = c ∗ ∣ x ) ) ≤ 2 P ∗ \begin{aligned}&\lim\limits_{K\rightarrow\infty}Err(x,x_i)=1-\sum_{c_j}P^2(a = c_j|x)\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =1-(P^2(a = c^*|x)+\sum_{c_j\neq c^*}P^2(a=c_j|x))\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \leq 1-P^2(a = c^*|x)\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ =(1+P(a = c^*|x))(1-P(a = c^*|x))\\ &\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \leq 2P^* \end{aligned} K→∞limErr(x,xi)=1−cj∑P2(a=cj∣x) =1−(P2(a=c∗∣x)+cj=c∗∑P2(a=cj∣x)) ≤1−P2(a=c∗∣x) =(1+P(a=c∗∣x))(1−P(a=c∗∣x)) ≤2P∗
另一方面,考虑误差率与 P ∗ P^* P∗ 的关系,只需考虑 ∑ c j P 2 ( a = c j ∣ x ) \sum_{c_j}P^2(a = c_j|x) ∑cjP2(a=cj∣x) 与 P ( a = c ∗ ∣ x ) P(a=c^*|x) P(a=c∗∣x) 的关系,由于 P ( a = c ∗ ∣ x ) = max c j P ( a = c j ∣ x ) P(a=c^*|x)=\max_{c_j}P(a = c_j|x) P(a=c∗∣x)=maxcjP(a=cj∣x) 以及
P ( a = c ∗ ∣ x ) − ∑ c j P 2 ( a = c j ∣ x ) = P ( a = c ∗ ∣ x ) − P 2 ( a = c ∗ ∣ x ) − ∑ c j ≠ c ∗ P 2 ( a = c j ∣ x ) = P ( a = c ∗ ∣ x ) ( 1 − P ( a = c ∗ ∣ x ) ) − ∑ c j ≠ c ∗ P 2 ( a = c j ∣ x ) = P ( a = c ∗ ∣ x ) ( ∑ c j ≠ c ∗ P ( a = c j ∣ x ) ) − ∑ c j ≠ c ∗ P 2 ( a = c j ∣ x ) = ∑ c j ≠ c ∗ ( P ( a = c ∗ ∣ x ) − P ( a = c j ∣ x ) ) P ( a = c j ∣ x ) ≥ 0. \begin{aligned}&\ \ \ \ \ P(a=c^*|x)-\sum_{c_j}P^2(a = c_j|x)\\ &=P(a=c^*|x)-P^2(a=c^*|x)-\sum_{c_j\neq c^*}P^2(a = c_j|x)\\ &=P(a=c^*|x)(1-P(a=c^*|x))-\sum_{c_j\neq c^*}P^2(a = c_j|x)\\ &=P(a=c^*|x)(\sum_{c_j\neq c^*}P(a = c_j|x))-\sum_{c_j\neq c^*}P^2(a = c_j|x)\\ &=\sum_{c_j\neq c^*}(P(a=c^*|x)-P(a = c_j|x))P(a = c_j|x)\geq 0. \end{aligned} P(a=c∗∣x)−cj∑P2(a=cj∣x)=P(a=c∗∣x)−P2(a=c∗∣x)−cj=c∗∑P2(a=cj∣x)=P(a=c∗∣x)(1−P(a=c∗∣x))−cj=c∗∑P2(a=cj∣x)=P(a=c∗∣x)(cj=c∗∑P(a=cj∣x))−cj=c∗∑P2(a=cj∣x)=cj=c∗∑(P(a=c∗∣x)−P(a=cj∣x))P(a=cj∣x)≥0. 所以有: P ∗ ≤ lim K → ∞ E r r ( x , x i ) ≤ 2 P ∗ . P^*\leq\lim\limits_{K\rightarrow\infty}Err(x,x_i)\leq 2P^*. P∗≤K→∞limErr(x,xi)≤2P∗.
如果推广到 k k k 近邻法,可以令样本 N N N 趋于无穷大, K K K 也无穷大,此时的误差率应该趋于 P ∗ P^* P∗ ,也就是贝叶斯误差率,它所对应的就是最优决策的误差。因此,如果 K K K 足够大,在大样本的情况下,可以认为 k k k 近邻法是近似于最优决策。
图片来自于B站简博士的视频-侵权删。