径向基函数网络(Radial Basis Function Network)：就是将基假设函数进行线性聚合。html

径向基函数网络假设函数(RBF Network Hypothesis)

先回顾一下高斯支持向量机(Gaussian SVM)：web

g

s

v

m

(

x

)

=

sign

⁡

(

∑

S

V

α

n

y

n

exp

⁡

(

−

γ

∥

x

−

x

n

∥

2

)

+

b

)

g _ { \mathrm { svm } } ( \mathbf { x } ) = \operatorname { sign } \left( \sum _ { \mathrm { SV } } \alpha _ { n } y _ { n } \exp \left( - \gamma \left\| \mathbf { x } - \mathbf { x } _ { n } \right\| ^ { 2 } \right) + b \right)gsvm​(x)=sign(SV∑​αn​yn​exp(−γ∥x−xn​∥2)+b)算法

其其实是找出系数 α

n

\alpha_nαn​ 将以 x

n

\mathbf { x } _ { n }xn​ 为中心的高斯函数进行线性结合。网络

Gaussian kernel 又叫 Radial Basis Function (RBF) kernel，其中 Radial 指的是这里之关系 x

\mathbf { x }x 与中心 x

n

\mathbf { x } _ { n }xn​ 之间的距离(相似于一种放射线长度求解)。app

那么写出高斯支持向量机中的径向基假设函数：dom

g

n

(

x

)

=

y

n

exp

⁡

(

−

γ

∥

x

−

x

n

∥

2

)

g _ { n } ( \mathbf { x } ) = y _ { n } \exp \left( - \gamma \left\| \mathbf { x } - \mathbf { x } _ { n } \right\| ^ { 2 } \right)gn​(x)=yn​exp(−γ∥x−xn​∥2)机器学习

那么高斯支持向量机能够改写为：svg

g

s

v

m

(

x

)

=

sign

⁡

(

∑

S

V

α

n

g

n

(

x

)

+

b

)

g _ { \mathrm { svm} } ( \mathbf { x} ) = \operatorname { sign } \left( \sum _ { \mathrm { SV } } \alpha _ { n } g _ { n } ( \mathbf { x } ) + b \right)gsvm​(x)=sign(SV∑​αn​gn​(x)+b)函数

能够看出被选择的径向基假设函数的线性结合(linear aggregation of selected radial hypotheses)。学习

RBF Network 的网络结构示意图以下：

实际上 RBFNet 是 NNet 的一个分支，可见输出层虽然使用的是投票，可是这也是一种线性组合因此与神经网络是同样的。可是隐含层是不一样的，在神经网络中使用的是内积加 tanh 输出，而在 RBFNet 中使用的是距离计算加高斯函数。

那么能够写出 RBFNet 的输出假设函数：

h

(

x

)

=

Output

(

∑

m

=

1

M

β

m

RBF

⁡

(

x

,

μ

m

)

+

b

)

h ( \mathbf { x } ) = \text { Output } \left( \sum _ { m = 1 } ^ { M } \beta _ { m } \operatorname { RBF } \left( \mathbf { x } , \mu _ { m } \right) + b \right)h(x)=Output(m=1∑M​βm​RBF(x,μm​)+b)

其中 μ

m

\mu _ { m }μm​ 是中心点，β

m

\beta _ { m }βm​ 是投票系数。

对比与高斯支持向量机：

RBF(径向基函数)选择的是高斯函数。

Output(输出)选择 sign 作为二分类输出。

M 则是支持向量的个数(#SV)。

μ

m

\mu _ { m }μm​ 则是支持向量 x

m

\mathbf{x}_mxm​。

β

m

\beta _ { m }βm​ 则是经过 SVM Dual 问题求解 α

m

\alpha_mαm​ 与 y

m

y_mym​ 的乘积。

不失广泛性的来讲：若是要学习径向基函数网络的话，须要选择四个部分：径向基函数 RBF ，输出层假设函数 Output ，中心点的求取 μ

m

\mu _ { m }μm​ ，投票的系数 β

m

\beta _ { m }βm​。

实际上核技巧实际上就是根据在 Z

\mathcal ZZ 空间上的内积求取类似性，好比多项式核：

Poly

⁡

(

x

,

x

′

)

=

(

1

+

x

T

x

′

)

2

\operatorname { Poly } \left( \mathbf { x } , \mathbf { x } ^ { \prime } \right) = \left( 1 + \mathbf { x } ^ { T } \mathbf { x } ^ { \prime } \right) ^ { 2 }Poly(x,x′)=(1+xTx′)2

而RBF则是直接经过在 X

\mathcal XX 空间上的距离求取类似性，通常认为距离越近类似性越大，也就是说距离与类似性单调相关。好比下面这个截断类似性函数：

Truncated

(

x

,

x

′

)

=

[

∥

x

−

x

′

∥

≤

1

]

(

1

−

∥

x

−

x

′

∥

)

2

\text { Truncated } \left( \mathbf { x } , \mathbf { x } ^ { \prime } \right) = \left[ \left\| \mathbf { x } - \mathbf { x } ^ { \prime } \right\| \leq 1 \right] \left( 1 - \left\| \mathbf { x } - \mathbf { x } ^ { \prime } \right\| \right) ^ { 2 }Truncated(x,x′)=[∥x−x′∥≤1](1−∥x−x′∥)2

而高斯函数则处于他们的交集。

Gaussian

(

x

,

x

′

)

=

exp

⁡

(

−

γ

∥

x

−

x

′

∥

2

)

\text { Gaussian } \left( \mathbf { x } , \mathbf { x } ^ { \prime } \right) = \exp \left( - \gamma \left\| \mathbf { x } - \mathbf { x } ^ { \prime } \right\| ^ { 2 } \right)Gaussian(x,x′)=exp(−γ∥x−x′∥2)

类似性是很好的一种特征转换方法。在RBF中则是将中心距离类似性做为特征转换的。其余的类似性函数好比神经元函数或者DNA序列类似性函数：

Neuron

(

x

,

x

′

)

=

tanh

⁡

(

γ

x

T

x

′

+

1

)

DNASim

(

x

,

x

′

)

=

EditDistance

(

x

,

x

′

)

\begin{array} { c } \text { Neuron } \left( \mathbf { x } , \mathbf { x } ^ { \prime } \right) = \tanh \left( \gamma \mathbf { x } ^ { T } \mathbf { x } ^ { \prime } + 1 \right) \\ \text { DNASim } \left( \mathbf { x } , \mathbf { x } ^ { \prime } \right) = \text { EditDistance } \left( \mathbf { x } , \mathbf { x } ^ { \prime } \right) \end{array}Neuron(x,x′)=tanh(γxTx′+1)DNASim(x,x′)=EditDistance(x,x′)​

RBF网络的训练/学习(RBF Network Learning)

彻底RBF网络(Full RBF Network)

若是不考虑 bais ，那么能够写为：

h

(

x

)

=

Output

⁡

(

∑

m

=

1

M

β

m

RBF

⁡

(

x

,

μ

m

)

)

h ( \mathbf { x } ) = \operatorname { Output } \left( \sum _ { m = 1 } ^ { M } \beta _ { m } \operatorname { RBF } \left( \mathbf { x } , \boldsymbol { \mu } _ { m } \right) \right)h(x)=Output(m=1∑M​βm​RBF(x,μm​))

若是令 M

=

N

M = NM=N 而且每个 μ

m

=

x

m

\mu _ { m } = \mathbf { x } _ { m }μm​=xm​ 那么这个RBF网络即是彻底RBF网络(full RBF Network)。这么作的物理意义是 x

m

\mathbf { x } _ { m }xm​ 将经过系数 β

m

\beta_ { m }βm​ 来影响每个与之类似的 x

\mathbf xx。

那么举例来讲，若是使用一个 uniform influence 即 β

m

=

1

⋅

y

m

\beta _ { m } = 1 \cdot y _ { m }βm​=1⋅ym​，也就是说你们票数一致。

g

unitorm

(

x

)

=

sign

⁡

(

∑

m

=

1

N

y

m

⁡

exp

⁡

(

−

γ

∥

x

−

x

m

∥

2

)

)

g _ { \text {unitorm } } ( \mathbf { x } ) = \operatorname { sign } \left( \sum _ { m = 1 } ^ { N } y _ { \operatorname { m} } \exp \left( - \gamma \left\| \mathbf { x } - \mathbf { x } _ { m } \right\| ^ { 2 } \right) \right)gunitorm​(x)=sign(m=1∑N​ym​exp(−γ∥x−xm​∥2))

因此说彻底RBF网络是一种偷懒的作法，省去了中心向量 μ

m

\mu _ mμm​ 的求取。

最邻近算法(Nearest Neighbor)

因为高斯函数衰减很快，那么会致使离中心最近的值会得到很大的权重，支配(dominates)投票过程，也就是说具备 “独断权”。因此这个过程更相似于选择一个最大值(最近向量)，而不是聚合过程。即：

g

nbor

(

x

)

=

y

m

such that

x

closest to

x

m

g _ { \text {nbor } } ( \mathbf { x } ) = y _ { m } \text { such that } \mathbf { x } \text { closest to } \mathbf { x } _ { m }gnbor​(x)=ym​such thatxclosest toxm​

因此叫作最邻近模型(nearest neighbor model)。

经常使用的是 K 邻近模型，根矩 Top k 最邻近的样本进行均值投票(uniformly aggregate k neighbor)，虽然很懒(lazy)可是很直观。

无正则化用于插值(Interpolation)

那么若是用于 Regression，那么以平方偏差做为偏差测量函数，最后的假设函数能够写为：

h

(

x

)

=

(

∑

m

=

1

N

β

m

RBF

⁡

(

x

,

x

m

)

)

h(\mathbf x) = \left( \sum _ { m = 1 } ^ { N } \beta _ { m } \operatorname { RBF } \left( \mathbf { x } , \mathbf { x } _ { m } \right) \right)h(x)=(m=1∑N​βm​RBF(x,xm​))

能够看出这就是在经过 RBF 映射到的空间上训练线性回归模型

那映射后的数据表示为：

z

n

=

[

RBF

⁡

(

x

n

,

x

1

)

,

RBF

⁡

(

x

n

,

x

2

)

,

…

,

RBF

⁡

(

x

n

,

x

N

)

]

\mathbf { z } _ { n } = \left[ \operatorname { RBF } \left( \mathbf { x } _ { n } , \mathbf { x } _ { 1 } \right) , \operatorname { RBF } \left( \mathbf { x } _ { n } , \mathbf { x } _ { 2 } \right) , \ldots , \operatorname { RBF } \left( \mathbf { x } _ { n } , \mathbf { x } _ { N } \right) \right]zn​=[RBF(xn​,x1​),RBF(xn​,x2​),…,RBF(xn​,xN​)]

矩阵 Z

\mathrm { Z }Z 由 n

nn 个 z

n

\mathbf { z } _ { n }zn​ 构成，因此矩阵 Z

\mathrm { Z }Z 为 N

(example)

×

N

(centers)

N\text{(example)} \times N\text{(centers)}N(example)×N(centers) 的对称方阵(symmetric square matrix)，根据线性回归能够写出 β

\betaβ 的最优解：

β

=

(

Z

T

Z

)

−

1

Z

T

y

,

if

Z

T

Z

invertible

\beta = \left( \mathrm { Z } ^ { T } \mathrm { Z } \right) ^ { - 1 } \mathrm { Z } ^ { T } \mathbf { y } , \text { if } \mathrm { Z } ^ { T } \mathrm { Z } \text { invertible }β=(ZTZ)−1ZTy,ifZTZinvertible

那么若是所有的 x

n

\mathbf { x } _ { n }xn​ 的都是不一样的，那么 Z

\mathrm { Z }Z (with Gaussian RBF)即是可逆的(invertible)。

又由于 Z

\mathrm { Z }Z 是对称方阵，也就是说 Z

T

=

Z

\mathrm { Z }^T = \mathrm { Z }ZT=Z。那么能够化简为：

β

=

(

Z

Z

)

−

1

Z

y

=

Z

−

1

y

\beta = \left( \mathrm { Z } \mathrm { Z } \right) ^ { - 1 } \mathrm { Z } \mathbf { y } = \mathrm { Z } ^ { - 1 } \mathbf { y }β=(ZZ)−1Zy=Z−1y

正则化(Regularization)

那么 x

1

\mathrm { x } _ { 1 }x1​ 的 RBF的网络输出为：

g

R

B

F

(

x

1

)

=

β

T

z

1

=

y

T

Z

−

1

(

first column of

Z

)

=

y

T

[

1

0

…

0

]

T

=

y

1

g _ { \mathrm { RBF } } \left( \mathrm { x } _ { 1 } \right) = \boldsymbol { \beta } ^ { T } \mathrm { z } _ { 1 } = \mathbf { y } ^ { T } \mathrm { Z } ^ { - 1 } ( \text {first column of } \mathrm { Z } ) = \mathbf { y } ^ { T } \left[ \begin{array} { l l l l } 1 & 0 & \ldots & 0 \end{array} \right] ^ { T } = y _ { 1 }gRBF​(x1​)=βTz1​=yTZ−1(first column ofZ)=yT[1​0​…​0​]T=y1​

也就是说 g

R

B

F

(

x

n

)

=

y

n

,

i.e.

E

i

n

(

g

R

B

F

)

=

0

g _ { \mathrm { RBF } } \left( \mathrm { x } _ { n } \right) = y _ { n } , \text { i.e. } E _ { \mathrm { in } } \left( g _ { \mathrm { RBF } } \right) = 0gRBF​(xn​)=yn​,i.e.Ein​(gRBF​)=0，那么这样的结果用于精确插值的函数估计(exact interpolation for function approximation)是很是好的，可是在机器学习中便会出现过拟合问题。因此能够加入 Regularization，固然前面学习过岭回归(ridge regression)，能够将 regularized full RBFNet β

\betaβ 的求解改写为：

β

=

(

Z

T

Z

+

λ

I

)

−

1

Z

T

y

\beta = \left( \mathrm { Z } ^ { T } \mathrm { Z } + \lambda \mathrm { I } \right) ^ { - 1 } \mathrm { Z } ^ { T } \mathrm { y }β=(ZTZ+λI)−1ZTy

在 kernel ridge regression 中，有一个 K

\mathbf { K }K 矩阵：

Z

=

[

Gaussian

(

x

n

,

x

m

)

]

=

Gaussian kernel matrix

K

\mathrm { Z } = \left[ \text {Gaussian } \left( \mathbf { x } _ { n } , \mathbf { x } _ { m } \right) \right] = \text { Gaussian kernel matrix } \mathbf { K }Z=[Gaussian(xn​,xm​)]=Gaussian kernel matrixK

在 kernel ridge regression 中，β

\betaβ 的求解为：

β

=

(

K

+

λ

I

)

−

1

y

\beta = ( \mathrm { K } + \lambda \mathrm { I } ) ^ { - 1 } \mathrm { y }β=(K+λI)−1y

二者很相近，可是因为正则化的对象不一样因此求解公式也不一样，在核岭回归中的针对的正则化对象为无限多维的转换。而 RBF 中针对的是有限多维的 N

NN 维的转换。

K均值算法(k-Means Algorithm)

反观 SVM，实际上并无使用到所有的 x

n

\mathbf x_nxn​ ，而只是用到了支持向量，即 M

≪

N

M \ll NM≪N。

g

s

v

m

(

x

)

=

sign

⁡

(

∑

S

V

α

m

y

m

exp

⁡

(

−

γ

∥

x

−

x

m

∥

2

)

+

b

)

g _ { \mathrm { svm } } ( \mathbf { x } ) = \operatorname { sign } \left( \sum _ { \mathrm { SV } } \alpha _ { m } y _ { m } \exp \left( - \gamma \left\| \mathbf { x } - \mathbf { x } _ { m } \right\| ^ { 2 } \right) + b \right)gsvm​(x)=sign(SV∑​αm​ym​exp(−γ∥x−xm​∥2)+b)

也就是经过限制中心的个数和投票的权重来达到正则化的效果(regularization by constraining number of centers and voting weights)。

如今的思路是找出一些“中心”表明(prototypes)。

聚类问题(Clustering Problem)

找表明的过程其实是一种聚类问题。什么意思呢？

if

x

1

≈

x

2

⟹

no need both

RBF

⁡

(

x

,

x

1

)

&

RBF

⁡

(

x

,

x

2

)

in RBFNet

⟹

cluster

x

1

and

x

2

by one prototype

μ

≈

x

1

≈

x

2

\begin{array} { l } \quad \text { if } \mathbf { x } _ { 1 } \approx \mathbf { x } _ { 2 } \\ \Longrightarrow \text { no need both } \operatorname { RBF } \left( \mathbf { x } , \mathbf { x } _ { 1 } \right) \& \operatorname { RBF } \left( \mathbf { x } , \mathbf { x } _ { 2 } \right) \text { in RBFNet } \\ \Longrightarrow \text { cluster } \mathbf { x } _ { 1 } \text { and } \mathbf { x } _ { 2 } \text { by one prototype } \mu \approx \mathbf { x } _ { 1 } \approx \mathbf { x } _ { 2 } \end{array}ifx1​≈x2​⟹no need bothRBF(x,x1​)&RBF(x,x2​)in RBFNet⟹clusterx1​andx2​by one prototypeμ≈x1​≈x2​​

也就是说 RBF

⁡

(

x

,

x

1

)

\operatorname { RBF } \left( \mathbf { x } , \mathbf { x } _ { 1 } \right)RBF(x,x1​) 能够很大程度上表明(表示) RBF

⁡

(

x

,

x

2

)

\operatorname { RBF } \left( \mathbf { x } , \mathbf { x } _ { 2 } \right)RBF(x,x2​)。

那么这种经过表明(代理人)进行聚类(clustering with prototype)的过程为：

将 {

x

n

}

\left\{ \mathbf { x } _ { n } \right\}{xn​} 分为M个互斥(不想交)的集合(disjoint sets)：S

1

,

S

2

,

⋯

,

S

M

S _ { 1 } , S _ { 2 } , \cdots , S _ { M }S1​,S2​,⋯,SM​。

为每个 S

m

S_mSm​ 选择最佳的 μ

m

≈

x

1

m

≈

⋯

≈

x

K

m

{ \mu } _ { m } \approx \mathbf { x } _ { 1_m } \approx \cdots \approx \mathbf { x } _ { K_m }μm​≈x1m​​≈⋯≈xKm​​ ，其中 x

1

m

⋯

x

K

m

∈

S

m

\mathbf { x } _ { 1_m } \cdots \mathbf { x } _ { K_m } \in S _ { m }x1m​​⋯xKm​​∈Sm​。

使用平方测量的聚类偏差

E

i

n

(

S

1

,

⋯

,

S

M

;

μ

1

,

⋯

,

μ

M

)

=

1

N

∑

n

=

1

N

∑

m

=

1

M

[

x

n

∈

S

m

]

∥

x

n

−

μ

m

∥

2

E _ { \mathrm { in } } \left( S _ { 1 } , \cdots , S _ { M } ; \mu _ { 1 } , \cdots , \mu _ { M } \right) = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \sum _ { m = 1 } ^ { M } \left[ \mathbf { x } _ { n } \in S _ { m } \right] \left\| \mathbf { x } _ { n } - \boldsymbol { \mu } _ { m } \right\| ^ { 2 }Ein​(S1​,⋯,SM​;μ1​,⋯,μM​)=N1​n=1∑N​m=1∑M​[xn​∈Sm​]∥xn​−μm​∥2

因此如今的聚类问题的优化目标为：

min

⁡

{

S

1

,

⋯

,

S

M

:

μ

1

,

⋯

,

μ

M

}

E

i

n

(

S

1

,

⋯

,

S

M

;

μ

1

,

⋯

,

μ

M

)

\min _ { \left\{ S _ { 1 } , \cdots , S _ { M } : \mu _ { 1 } , \cdots , \mu _ { M } \right\} } E _ { i n } \left( S _ { 1 } , \cdots , S _ { M } ; \mu _ { 1 } , \cdots , \mu _ { M } \right){S1​,⋯,SM​:μ1​,⋯,μM​}min​Ein​(S1​,⋯,SM​;μ1​,⋯,μM​)

优化(Optimization)

在优化过程当中涉及到两个部分的最佳化问题：如何分群以及如何寻找中心点。

这样的组合和数值( combinatorial-numerical optimization)两个问题结合优化的过程是比较难以优化的：

那么若是只对一个问题寻优，那么问题就会简单不少。

分区寻优(Partition Optimization)

假设 μ

1

,

μ

2

,

…

,

μ

k

\mu _ { 1 } , \mu _ { 2 } , \ldots , \mu _ { k }μ1​,μ2​,…,μk​ 已经固定，那么一个又一个地经过下面这个公式选择最优的组群：

optimal chosen subset

S

m

=

the one with minimum

∥

x

n

−

μ

m

∥

2

\text { optimal chosen subset } S _ { m } = \text { the one with minimum } \left\| \mathbf { x } _ { n } - \boldsymbol { \mu } _ { m } \right\| ^ { 2 }optimal chosen subsetSm​=the one with minimum∥xn​−μm​∥2

也就是对于每个 x

n

\mathbf { x } _ { n }xn​ 都在 μ

1

,

μ

2

,

…

,

μ

k

\mu _ { 1 } , \mu _ { 2 } , \ldots , \mu _ { k }μ1​,μ2​,…,μk​ 中选择最近的 μ

m

\mu _ { m }μm​ ，并以此为依据进行最优分区(optimally partitioned)。

表明寻优(Prototype Optimization)

假设 S

1

,

⋯

,

S

M

S _ { 1 } , \cdots , S _ { M }S1​,⋯,SM​ 已经固定，那么这个优化问题便成为了一个关于每个 μ

m

\mu _ mμm​ 的无约束最优化问题：

∇

μ

m

E

i

n

=

−

2

∑

n

=

1

N

[

x

n

∈

S

m

]

[

x

n

−

μ

m

)

=

−

2

(

(

∑

x

n

∈

S

m

x

n

)

−

∣

S

m

∣

μ

m

)

\nabla _ { \boldsymbol { \mu } _ { m } } E _ { \mathrm { in } } = - 2 \sum _ { n = 1 } ^ { N } \left[ \mathbf { x } _ { n } \in S _ { m } \right] \left[ \mathbf { x } _ { n } - \boldsymbol { \mu } _ { m } \right) = - 2 \left( \left( \sum _ { \mathbf { x } _ { n } \in S _ { m } } \mathbf { x } _ { n } \right) - \left| S _ { m } \right| \boldsymbol { \mu } _ { m } \right)∇μm​​Ein​=−2n=1∑N​[xn​∈Sm​][xn​−μm​)=−2((xn​∈Sm​∑​xn​)−∣Sm​∣μm​)

能够看出来最优的表明值即是所有样本的平均值：

optimal prototype

μ

m

=

average of

x

n

within

S

m

\text { optimal prototype } \mu _ { m } = \text { average of } \mathbf { x } _ { n } \text { within } S _ { m }optimal prototypeμm​=average ofxn​withinSm​

对于每一个 S

1

,

S

2

,

…

,

S

k

S _ { 1 } , S _ { 2 } , \ldots , S _ { k }S1​,S2​,…,Sk​ 都求均值做为最佳 μ

m

\mu_mμm​ 的计算方法(optimally computed)。

具体实现

(1) initialize

μ

1

,

μ

2

,

…

,

μ

k

:

say, as

k

randomly chosen

x

n

(2) alternating optimization of

E

in

: repeatedly

(1) Optimize

S

1

,

S

2

,

…

,

S

k

:

each

x

n

optimally partitioned using its closest

μ

i

(2) Optimize

μ

1

,

μ

2

,

…

,

μ

k

: each

μ

n

optimally computed as the consensus within

S

m

until converge

\begin{array} { l } \text { (1) initialize } \mu _ { 1 } , \mu _ { 2 } , \ldots , \mu _ { k } : \text { say, as } k \text { randomly chosen } x _ { n } \\ \text { (2) alternating optimization of } E _ { \text {in } } \text { : repeatedly } \\ \qquad \text { (1) Optimize } S _ { 1 } , S _ { 2 } , \ldots , S _ { k } : \text { each } x _ { n } \text { optimally partitioned using its closest } \mu _ { i } \\ \qquad \text { (2) Optimize } \mu _ { 1 } , \mu _ { 2 } , \ldots , \mu _ { k } \text { : each } \mu _ { n } \text { optimally computed as the consensus within } S _ { m } \\ \qquad \text { until converge } \end{array}(1) initializeμ1​,μ2​,…,μk​:say, askrandomly chosenxn​(2) alternating optimization ofEin​: repeatedly(1) OptimizeS1​,S2​,…,Sk​:eachxn​optimally partitioned using its closestμi​(2) Optimizeμ1​,μ2​,…,μk​: eachμn​optimally computed as the consensus withinSm​until converge​

收敛(converge )：S

1

,

S

2

,

…

,

S

k

S _ { 1 } , S _ { 2 } , \ldots , S _ { k }S1​,S2​,…,Sk​ 再也不改变。由于上述的交替迭代过程是使得 E

in

E _ { \text {in } }Ein​ 不断变小的过程，同时E

in

E _ { \text {in } }Ein​ 的最小值为 0，因此必然收敛。

因为交替寻优(alternating minimization)的特性，K均值算法成为了最流行的距离算法。

正则化RBF网络

使用K均值算法，找出K个具备表明性的 μ

k

\mu _ kμk​，来构造 N

(examples)

×

K

(centers)

N \text{(examples)} \times K \text{(centers)}N(examples)×K(centers) 的 Z

\mathrm{Z}Z 矩阵。

那么 RBF Network Using k-Means 的实现过程为：

(1) run

k

-Means with

k

=

M

to get

{

μ

m

}

(2) construct transform

Φ

(

x

)

from RBF (say, Gaussian) at

μ

m

Φ

(

x

)

=

[

RBF

⁡

(

x

,

μ

1

)

,

RBF

⁡

(

x

,

μ

2

)

,

…

,

RBF

⁡

(

x

,

μ

M

)

]

(3) run linear model on

{

(

Φ

(

x

n

)

,

y

n

)

}

to get

β

(4) return

g

RBFNET

(

x

)

=

LinearHypothesis

(

β

,

Φ

(

x

)

)

\begin{array} { l } \text { (1) run } k \text { -Means with } k = M \text { to get } \left\{ \boldsymbol { \mu } _ { m } \right\} \\ \text { (2) construct transform } \Phi ( \mathbf { x } ) \text { from RBF (say, Gaussian) at } \mu _ { m } \\ \qquad \mathbf { \Phi } ( \mathbf { x } ) = \left[ \operatorname { RBF } \left( \mathbf { x } , \mu _ { 1 } \right) , \operatorname { RBF } \left( \mathbf { x } , \mu _ { 2 } \right) , \ldots , \operatorname { RBF } \left( \mathbf { x } , \mu _ { M } \right) \right] \\ \text { (3) run linear model on } \left\{ \left( \mathbf { \Phi } \left( \mathbf { x } _ { n } \right) , y _ { n } \right) \right\} \text { to get } \beta \\ \text { (4) return } g _ { \text {RBFNET } } ( \mathbf { x } ) = \text { LinearHypothesis } ( \boldsymbol { \beta } , \mathbf { \Phi } ( \mathbf { x } ) ) \end{array}(1) runk-Means withk=Mto get{μm​}(2) construct transformΦ(x)from RBF (say, Gaussian) atμm​Φ(x)=[RBF(x,μ1​),RBF(x,μ2​),…,RBF(x,μM​)](3) run linear model on{(Φ(xn​),yn​)}to getβ(4) returngRBFNET​(x)=LinearHypothesis(β,Φ(x))​

这实际上就是使用无监督学习方法来辅助特征转换(using unsupervised learning (k-Means) to assist feature transform)。须要的参数有两个：一个是表明的个数 M

MM，另外一个是RBF的选择(好比中心为 γ

\gammaγ 的高斯函数)。

k-Means和RBF网络的实际应用(k-Means and RBF Network in Action)

K-Means in Action

下面展现k-Means算法的实际优化过程：

其中第一行是分区优化，第二行是表明(中心点)寻优。可看出合理的初始值和k能够得到不错的聚类效果。

RBF Network Using k-Means in Action

图中发黑的地方表明了高斯密度函数的分布形式。能够看出合理的中心点可使得 RBF Network 得到比较好的效果。

Full RBF Network in Action

最左边是使用了正则化的RBF的分类效果。最右边是最近邻算法的分类效果。由于二者在必定程度上都用到了所有的数据，因此看起来有些过拟合。因此在实际运用中彻底 RBF 网络不多使用。