RBF（径向基）神经网络——原来本质就是利用高斯核函数去做函数逼近，类似泰勒展开

RBF（径向基）神经网络

　　只要模型是一层一层的，并使用AD/BP算法，就能称作 BP神经网络。RBF 神经网络是其中一个特例。本文主要包括以下内容：

• 什么是径向基函数
• RBF神经网络
• RBF神经网络的学习问题
• RBF神经网络与BP神经网络的区别
• RBF神经网络与SVM的区别
• 为什么高斯核函数就是映射到高维区间
• 前馈网络、递归网络和反馈网络
• 完全内插法

一、什么是径向基函数

　　1985年，Powell提出了多变量插值的径向基函数（RBF）方法。径向基函数是一个取值仅仅依赖于离原点距离的实值函数，也就是Φ（x）=Φ(‖x‖),或者还可以是到任意一点c的距离，c点称为中心点，也就是Φ（x，c）=Φ(‖x-c‖)。任意一个满足Φ（x）=Φ(‖x‖)特性的函数Φ都叫做径向基函数，标准的一般使用欧氏距离（也叫做欧式径向基函数），尽管其他距离函数也是可以的。最常用的径向基函数是高斯核函数 ,形式为 k(||x-xc||)=exp{- ||x-xc||^2/(2*σ)^2) } 其中x_c为核函数中心,σ为函数的宽度参数 , 控制了函数的径向作用范围。

二、RBF神经网络

　　RBF神将网络是一种三层神经网络，其包括输入层、隐层、输出层。从输入空间到隐层空间的变换是非线性的，而从隐层空间到输出层空间变换是线性的。流图如下：

　　RBF网络的基本思想是：用RBF作为隐单元的“基”构成隐含层空间，这样就可以将输入矢量直接映射到隐空间，而不需要通过权连接。当RBF的中心点确定以后，这种映射关系也就确定了。而隐含层空间到输出空间的映射是线性的，即网络的输出是隐单元输出的线性加权和，此处的权即为网络可调参数。其中，隐含层的作用是把向量从低维度的p映射到高维度的h，这样低维度线性不可分的情况到高维度就可以变得线性可分了，主要就是核函数的思想。这样，网络由输入到输出的映射是非线性的，而网络输出对可调参数而言却又是线性的。网络的权就可由线性方程组直接解出，从而大大加快学习速度并避免局部极小问题。

　　径向基神经网络的激活函数可表示为：

　　其中x_p为第p个输入样本，c_i为第i个中心点，h为隐含层的结点数，n是输出的样本数或分类数。径向基神经网络的结构可得到网络的输出为：

　　当然，采用最小二乘的损失函数表示：

三、RBF神经网络的学习问题

　　求解的参数有3个：基函数的中心、方差以及隐含层到输出层的权值。

　　（1）自组织选取中心学习方法：

　　第一步：无监督学习过程，求解隐含层基函数的中心与方差

　　第二步：有监督学习过程，求解隐含层到输出层之间的权值

　　首先，选取h个中心做k-means聚类，对于高斯核函数的径向基，方差由公式求解：

　　c_max为所选取中心点之间的最大距离。

　　隐含层至输出层之间的神经元的连接权值可以用最小二乘法直接计算得到，即对损失函数求解关于w的偏导数，使其等于0，可以化简得到计算公式为：

　　（2）直接计算法

　　隐含层神经元的中心是随机地在输入样本中选取，且中心固定。一旦中心固定下来，隐含层神经元的输出便是已知的，这样的神经网络的连接权就可以通过求解线性方程组来确定。适用于样本数据的分布具有明显代表性。

　　（3）有监督学习算法

　　通过训练样本集来获得满足监督要求的网络中心和其他权重参数，经历一个误差修正学习的过程，与BP网络的学习原理一样，同样采用梯度下降法。因此RBF同样可以被当作BP神经网络的一种。

 　　参考：http://read.pudn.com/downloads110/sourcecode/others/454289/Paper/pdf/y9935500004.pdf

四、RBF神经网络与BP神经网络之间的区别

　　1、局部逼近与全局逼近：　

　　BP神经网络的隐节点采用输入模式与权向量的内积作为激活函数的自变量，而激活函数采用Sigmoid函数。各调参数对BP网络的输出具有同等地位的影响，因此BP神经网络是对非线性映射的全局逼近。

　　RBF神经网络的隐节点采用输入模式与中心向量的距离（如欧式距离）作为函数的自变量，并使用径向基函数（如Gaussian函数）作为激活函数。神经元的输入离径向基函数中心越远，神经元的激活程度就越低（高斯函数）。RBF网络的输出与部分调参数有关，譬如，一个w_ij值只影响一个y_i的输出（参考上面第二章网络输出），RBF神经网络因此具有“局部映射”特性。

　　 　　所谓局部逼近是指目标函数的逼近仅仅根据查询点附近的数据。而事实上，对于径向基网络，通常使用的是高斯径向基函数，函数图象是两边衰减且径向对称的，当选取的中心与查询点（即输入数据）很接近的时候才对输入有真正的映射作用，若中心与查询点很远的时候，欧式距离太大的情况下，输出的结果趋于0，所以真正起作用的点还是与查询点很近的点，所以是局部逼近；而BP网络对目标函数的逼近跟所有数据都相关，而不仅仅来自查询点附近的数据。

　　2、中间层数的区别

　　BP神经网络可以有多个隐含层，但是RBF只有一个隐含层。

　　3、训练速度的区别

　　使用RBF的训练速度快，一方面是因为隐含层较少，另一方面，局部逼近可以简化计算量。对于一个输入x，只有部分神经元会有响应，其他的都近似为0，对应的w就不用调参了。

　　4、Poggio和Girosi已经证明，RBF网络是连续函数的最佳逼近，而BP网络不是。

五、RBF神经网络与SVM的区别

　　SVM等如果使用核函数的技巧的话，不太适应于大样本和大的特征数的情况，因此提出了RBF。

　　另外，SVM中的高斯核函数可以看作与每一个输入点的距离，而RBF神经网络对输入点做了一个聚类。RBF神经网络用高斯核函数时,其数据中心C可以是训练样本中的抽样，此时与svm的高斯核函数是完全等价的，也可以是训练样本集的多个聚类中心，所以他们都是需要选择数据中心的，只不过SVM使用高斯核函数时，这里的数据中心都是训练样本本身而已。

  

六、为什么高斯核函数就是映射到高维空间

 　　首先给出高斯核函数的定义公式：

　　实际上，可以化简为：

　　当然通过幂级数展开：

　　可以看到，其中X向量会生成类似多项式核展开的形式，譬如原来的参数有x1,x2。映射后，参数包含了x1*x1 ,x1*x2,x2*x2将原来2维映射到3维上了。

七、前馈网络、递归网络和反馈网络

　　前馈网络一般指前馈神经网络或前馈型神经网络。它是一种最简单的神经网络，各神经元分层排列。每个神经元只与前一层的神经元相连。接收前一层的输出，并输出给下一层，各层间没有反馈。包括：BP神经网络、RBF神经网络等。

　　递归神经网络（RNN）是两种人工神经网络的总称。一种是时间递归神经网络（recurrent neural network），又名循环神经网络，包括RNN、LSTM、GRU等；另一种是结构递归神经网络（recursive neural network）。

　　反馈网络(Recurrent Network)，又称自联想记忆网络，其目的是为了设计一个网络，储存一组平衡点，使得当给网络一组初始值时，网络通过自行运行而最终收敛到这个设计的平衡点上。包括CHNN、DHNN等。

 八、完全内插法　

　　之所以RBF能够拟合任意函数，可以从内插法的角度去理解。要拟合一个曲线，我们可以通过内插法获得这个曲线的表达函数，譬如：多项式插值、拉格朗日插值等。RBF 插值是一系列精确插值方法的组合；即表面必须通过每一个测得的采样值。

　　对于RBF插值，其特点即为，在输入数据集中，与中心点距离近的点对映射函数的贡献最大。　　

　　完全内插法即要求所有插值点都经过曲面，由于RBF内插对于每个x都有用到，所以是一种完全内插的形式，存在的问题就是当样本中包含噪声时，神经网络将拟合出一个错误的曲面，从而使泛化能力下降。另外，若样本x的数据远大于非线性函数φ，该求解变得不稳定，即为解超定方程。因此需要引入正则化方法，正则化的方法即通常加上正则化项。

在使用RBF神经网络实现函数逼近中，笔者介绍了使用 Matlab 训练RBF神经网络。本博客将介绍使用 tensorflow 训练RBF神经网络。代码资源见：RBF案例（更新版）

一些具体的逼近示例见：https://blog.csdn.net/m0_37602827/article/details/103099972

这几天，笔者在寻找 tensorflow 中 RBF 官方案例，没找到，又看了一些博客，发现这些博客或不能逼近多元函数，或不能批量训练。于是，自己手撕了一下代码。

RBF神经网络中需要求解的参数有4个：基函数的中心和方差、隐含层到输出层的权值和偏值。

RBF 神经网络的关键在于中心的选取，一般有如下三种方法：

直接计算法：直接通过先验经验固定中心，并计算方差，再通过有监督学习得到其他参数
自组织学习法：先通过k-means等聚类算法求出中心（无监督学习），并计算方差，再通过有监督学习得到其他参数
有监督学习法：直接通过有监督学习求出所有参数
在直接计算法和自组织学习法中，方差的计算公式如下：

其中 Cmax 表示 h 个中心间的最大距离。

本博客主要介绍后两种中心计算方法实现 RBF 神经网络。 

笔者工作空间如下：

2  RBF神经网络实现
2.1 自组织学习选取RBF中心
RBF_kmeans.py

import tensorflow as tf
import numpy as np
from sklearn.cluster import KMeans

class RBF:
#初始化学习率、学习步数
def __init__(self,learning_rate=0.002,step_num=10001,hidden_size=10):
self.learning_rate=learning_rate
self.step_num=step_num
self.hidden_size=hidden_size

#使用 k-means 获取聚类中心、标准差
def getC_S(self,x,class_num):
estimator=KMeans(n_clusters=class_num,max_iter=10000) #构造聚类器
estimator.fit(x) #聚类
c=estimator.cluster_centers_
n=len(c)
s=0;
for i in range(n):
j=i+1
while j<n:
t=np.sum((c[i]-c[j])**2)
s=max(s,t)
j=j+1
s=np.sqrt(s)/np.sqrt(2*n)
return c,s

#高斯核函数(c为中心，s为标准差)
def kernel(self,x,c,s):
x1=tf.tile(x,[1,self.hidden_size]) #将x水平复制 hidden次
x2=tf.reshape(x1,[-1,self.hidden_size,self.feature])
dist=tf.reduce_sum((x2-c)**2,2)
return tf.exp(-dist/(2*s**2))

#训练RBF神经网络
def train(self,x,y):
self.feature=np.shape(x)[1] #输入值的特征数
self.c,self.s=self.getC_S(x,self.hidden_size) #获取聚类中心、标准差

x_=tf.placeholder(tf.float32,[None,self.feature]) #定义placeholder
y_=tf.placeholder(tf.float32,[None,1]) #定义placeholder

#定义径向基层
z=self.kernel(x_,self.c,self.s)

#定义输出层
w=tf.Variable(tf.random_normal([self.hidden_size,1]))
b=tf.Variable(tf.zeros([1]))
yf=tf.matmul(z,w)+b

loss=tf.reduce_mean(tf.square(y_-yf))#二次代价函数
optimizer=tf.train.AdamOptimizer(self.learning_rate) #Adam优化器
train=optimizer.minimize(loss) #最小化代价函数
init=tf.global_variables_initializer() #变量初始化

with tf.Session() as sess:
sess.run(init)
for epoch in range(self.step_num):
sess.run(train,feed_dict={x_:x,y_:y})
if epoch>0 and epoch%500==0:
mse=sess.run(loss,feed_dict={x_:x,y_:y})
print(epoch,mse)
self.w,self.b=sess.run([w,b],feed_dict={x_:x,y_:y})

def kernel2(self,x,c,s): #预测时使用
x1=np.tile(x,[1,self.hidden_size]) #将x水平复制 hidden次
x2=np.reshape(x1,[-1,self.hidden_size,self.feature])
dist=np.sum((x2-c)**2,2)
return np.exp(-dist/(2*s**2))

def predict(self,x):
z=self.kernel2(x,self.c,self.s)
pre=np.matmul(z,self.w)+self.b
return pre
2.2 有监督学习选取RBF中心
RBF_Supervised.py

import numpy as np
import tensorflow as tf

class RBF:
#初始化学习率、学习步数
def __init__(self,learning_rate=0.002,step_num=10001,hidden_size=10):
self.learning_rate=learning_rate
self.step_num=step_num
self.hidden_size=hidden_size

#高斯核函数(c为中心，s为标准差)
def kernel(self,x,c,s): #训练时使用
x1=tf.tile(x,[1,self.hidden_size]) #将x水平复制 hidden次
x2=tf.reshape(x1,[-1,self.hidden_size,self.feature])
dist=tf.reduce_sum((x2-c)**2,2)
return tf.exp(-dist/(2*s**2))

#训练RBF神经网络
def train(self,x,y):
self.feature=np.shape(x)[1] #输入值的特征数
x_=tf.placeholder(tf.float32,[None,self.feature]) #定义placeholder
y_=tf.placeholder(tf.float32,[None,1]) #定义placeholder

#定义径向基层
c=tf.Variable(tf.random_normal([self.hidden_size,self.feature]))
s=tf.Variable(tf.random_normal([self.hidden_size]))
z=self.kernel(x_,c,s)

#定义输出层
w=tf.Variable(tf.random_normal([self.hidden_size,1]))
b=tf.Variable(tf.zeros([1]))
yf=tf.matmul(z,w)+b

loss=tf.reduce_mean(tf.square(y_-yf))#二次代价函数
optimizer=tf.train.AdamOptimizer(self.learning_rate) #Adam优化器
train=optimizer.minimize(loss) #最小化代价函数
init=tf.global_variables_initializer() #变量初始化

with tf.Session() as sess:
sess.run(init)
for epoch in range(self.step_num):
sess.run(train,feed_dict={x_:x,y_:y})
if epoch>0 and epoch%500==0:
mse=sess.run(loss,feed_dict={x_:x,y_:y})
print(epoch,mse)
self.c,self.s,self.w,self.b=sess.run([c,s,w,b],feed_dict={x_:x,y_:y})

def kernel2(self,x,c,s): #预测时使用
x1=np.tile(x,[1,self.hidden_size]) #将x水平复制 hidden次
x2=np.reshape(x1,[-1,self.hidden_size,self.feature])
dist=np.sum((x2-c)**2,2)
return np.exp(-dist/(2*s**2))

def predict(self,x):
z=self.kernel2(x,self.c,self.s)
pre=np.matmul(z,self.w)+self.b
return pre
3 案例
3.1 一元函数逼近
待逼近函数：

（1）自组织学习选取RBF中心

test_kmeans.py

import numpy as np
import matplotlib.pyplot as plt
from RBF_kmeans import RBF

#待逼近的函数
def fun(x):
return x*x+2*x*np.sin(x)-np.exp(-x)/10

#生成样本
def generate_samples():
n=150 #样本点个数
wideX=0.03 #横轴噪声的宽度
wideY=0.5 #纵轴噪声宽度
t=np.linspace(-5,5,n).reshape(-1,1) #横轴理想值
u=fun(t) #纵轴理想值
noisyX=np.random.uniform(-wideX,wideX,n).reshape(n,-1) #横轴噪声
noisyY=np.random.uniform(-wideY,wideY,n).reshape(n,-1) #纵轴噪声
x=t+noisyX #横轴实际值
y=u+noisyY #纵轴实际值
return t,u,x,y

t,u,x,y=generate_samples()
rbf=RBF(0.003,20001,4) #学习率
rbf.train(x,y)
pre=rbf.predict(t)
plt.plot(x,y,'+')
plt.plot(t,u)
plt.plot(t,pre)
plt.legend(['dot','real','pre'],loc='upper left')

自组织学习选取RBF中心
 （2）有监督学习选取RBF中心

test_Supervised.py

import numpy as np
import matplotlib.pyplot as plt
from RBF_Supervised import RBF

#待逼近的函数
def fun(x):
return x*x+2*x*np.sin(x)-np.exp(-x)/10

#生成样本
def generate_samples():
n=150 #样本点个数
wideX=0.03 #横轴噪声的宽度
wideY=0.5 #纵轴噪声宽度
t=np.linspace(-5,5,n).reshape(-1,1) #横轴理想值
u=fun(t) #纵轴理想值
noisyX=np.random.uniform(-wideX,wideX,n).reshape(n,-1) #横轴噪声
noisyY=np.random.uniform(-wideY,wideY,n).reshape(n,-1) #纵轴噪声
x=t+noisyX #横轴实际值
y=u+noisyY #纵轴实际值
return t,u,x,y

t,u,x,y=generate_samples()
rbf=RBF(0.003,20001,4) #学习率
rbf.train(x,y)
pre=rbf.predict(t)
plt.plot(x,y,'+')
plt.plot(t,u)
plt.plot(t,pre)
plt.legend(['dot','real','pre'],loc='upper left')

有监督学习选取RBF中心
3.2 二元函数逼近
待逼近函数：

（1）自组织学习选取RBF中心

test_kmeans2.py

import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from RBF_kmeans import RBF

#待逼近的函数
def fun(t):
x1=(t+0.5*np.pi)*np.sin(t+0.5*np.pi)
x2=(t+0.5*np.pi)*np.cos(t+0.5*np.pi)
y=1.5*t
x=np.append(x1,x2,1)
return x,y

#生成样本
def generate_samples():
n=200 #样本点个数
wideX=0.6 #水平方向噪声的宽度
wideY=1 #纵轴噪声宽度
t=np.linspace(0,10*np.pi,n).reshape(-1,1) #横轴理想值
u,v=fun(t) #纵轴理想值
noisyX=np.random.uniform(-wideX,wideX,u.shape).reshape(n,-1) #水平方向噪声
noisyY=np.random.uniform(-wideY,wideY,n).reshape(n,-1) #纵轴噪声
x=u+noisyX #横轴实际值
y=v+noisyY #纵轴实际值
return u,v,x,y

u,v,x,y=generate_samples()
rbf=RBF(0.02,20001,10) #学习率
rbf.train(x,y)
pre=rbf.predict(u)

ax=plt.figure().gca(projection='3d')
ax.plot(x[:,0],x[:,1],y[:,0],'+')
ax.plot(u[:,0],u[:,1],v[:,0])
ax.plot(u[:,0],u[:,1],pre[:,0])
plt.legend(['dot','real','pre'],loc='upper left')
plt.show()

自组织学习选取RBF中心
 

（2）有监督学习选取RBF中心

test_Supervised2.py

import numpy as np
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
from RBF_Supervised import RBF

#待逼近的函数
def fun(t):
x1=(t+0.5*np.pi)*np.sin(t+0.5*np.pi)
x2=(t+0.5*np.pi)*np.cos(t+0.5*np.pi)
y=1.5*t
x=np.append(x1,x2,1)
return x,y

#生成样本
def generate_samples():
n=200 #样本点个数
wideX=0.6 #水平方向噪声的宽度
wideY=1 #纵轴噪声宽度
t=np.linspace(0,10*np.pi,n).reshape(-1,1) #横轴理想值
u,v=fun(t) #纵轴理想值
noisyX=np.random.uniform(-wideX,wideX,u.shape).reshape(n,-1) #水平方向噪声
noisyY=np.random.uniform(-wideY,wideY,n).reshape(n,-1) #纵轴噪声
x=u+noisyX #横轴实际值
y=v+noisyY #纵轴实际值
return u,v,x,y

u,v,x,y=generate_samples()
rbf=RBF(0.02,20001,10) #学习率
rbf.train(x,y)
pre=rbf.predict(u)

ax=plt.figure().gca(projection='3d')
ax.plot(x[:,0],x[:,1],y[:,0],'+')
ax.plot(u[:,0],u[:,1],v[:,0])
ax.plot(u[:,0],u[:,1],pre[:,0])
plt.legend(['dot','real','pre'],loc='upper left')
plt.show()
 

有监督学习选取RBF中心
 通过实验可以看到：无论是一元函数逼近还是二元函数逼近，在隐藏层神经元个数、学习率、学习步数相同的情况下，有监督学习法都比自组织学习法效果好。
————————————————
版权声明：本文为CSDN博主「little_fat_sheep」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_37602827/article/details/103099972