1 前言
在使用RBF神经网络实现函数逼近中，笔者介绍了使用 Matlab 训练RBF神经网络。本博客将介绍使用 tensorflow 训练RBF神经网络。代码资源见：RBF案例（更新版）
这几天，笔者在寻找 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 pre2.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 pre3 案例
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')
（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')
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()
（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()
通过实验可以看到：无论是一元函数逼近还是二元函数逼近，在隐藏层神经元个数、学习率、学习步数相同的情况下，有监督学习法都比自组织学习法效果好。
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
