（python源码）基于tensorflow的径向基向量bp神经网络
基于tensorflow的rbf神经网络_python源码实现
该网络结果比较简单，输入层--径向基层--输出层，其中需要迭代优化的是：“径向基层”--“输出层”之间的权重（weights和biases）。
#encoding:utf-8
import numpy as np
import tensorflow as tf
import os
PI = 3.1415926535898
min_,max_ = -5,5
class rbf_bp:
# 对输入值进行径向基向量计算
def kernel_(self,x_):
#函数：两点之间的欧式距离
self.distant_ = lambda x1,x2:np.sqrt(np.sum(np.square(x1-x2)))
#函数：高斯核
#self.Gaussian = lambda x:np.exp(-np.power(x/self.gamma,2))
self.Gaussian = lambda x:x**self.gamma
mount_ = x_.shape[0]
x_dis = np.zeros((mount_,self.num_)) #中间矩阵:存储两点之间的距离
matrix_ = np.zeros((mount_,self.num_)) #距离，进行高斯核变换
for i in xrange(mount_):
for j in xrange(self.num_):
x_dis[i,j]=self.distant_(x_[i],self.x_nodes[j])
matrix_[i,j]=self.Gaussian(x_dis[i,j])
return matrix_
def __init__(self,x_nodes,y_nodes,gamma):
#节点的x坐标值
self.x_nodes = x_nodes
#高斯系数
self.gamma = gamma
self.num_ = len(y_nodes) #节点数
matrix_ = self.kernel_(x_nodes)
#计算初始化权重weights_
weights_ = np.dot(np.linalg.pinv(matrix_),y_nodes.copy())
#定义一个两层的网络，第1层为高斯核函数节点的输出，第2层为回归的值
self.x_ = tf.placeholder(tf.float32,shape=(None,x_nodes.shape[0]),name="x_")
self.y_ = tf.placeholder(tf.float32,shape=(None),name="y_")
weights_ = weights_[:, np.newaxis]
self.weights = tf.Variable(weights_,name = "weights", dtype=tf.float32)
self.biaes = tf.Variable(0.0,name = "biaes", dtype=tf.float32)
self.predict_ = tf.matmul(self.x_,self.weights) + self.biaes
self.loss = tf.reduce_mean(tf.square(self.y_-self.predict_))
self.err_rate = tf.reduce_mean(tf.abs((self.y_-self.predict_)/self.y_))
def train(self,x_train,y_train,x_test,y_test,batch_size,learn_rate,circles_):
print x_train.shape
x_train = self.kernel_(x_train)
print x_train.shape
x_test = self.kernel_(x_test)
self.train_ = tf.train.GradientDescentOptimizer(learn_rate).minimize(self.loss)
saver = tf.train.Saver()
size_ = x_train.shape[0] #训练集的数量
with tf.Session() as sess:
sess.run(tf.initialize_all_variables())
for step_ in range(circles_): #训练次数
start = int((step_*batch_size)%(size_-1))
end = start+batch_size
if end<(size_-1):
in_x = x_train[start:end,:]
in_y = y_train[start:end]
else:
end_ = end%(size_-1)
in_x = np.concatenate((x_train[start:size_-1,:],x_train[0:end_,:]))
in_y = np.concatenate((y_train[start:size_-1],y_train[0:end_]))
if step_%50 == 0:
print "第",step_,"次迭代"
print "test_错误率：", sess.run(self.err_rate, feed_dict={self.x_:x_test,self.y_:y_test})
print "train_错误率：",sess.run(self.err_rate, feed_dict={self.x_:in_x,self.y_:in_y})
#print "predict:",sess.run(self.predict_, feed_dict={self.x_:in_x,self.y_:in_y})
sess.run(self.train_, feed_dict={self.x_:in_x,self.y_:in_y})
os.mkdir("./Model")
saver.save(sess,"Model/model.ckpt")
def predict(self,x_data,y_data):
x_data = self.kernel_(x_data)
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess,"Model/model.ckpt")
prediction = sess.run(self.predict_, feed_dict={self.x_:x_data,self.y_:y_data})
return prediction
def gen_y(x):
y = np.zeros((x.shape[0]))
for i in range(x.shape[0]):
x_ = x[i]
y[i] = np.sin(x_)
return y
def main():
x_input = np.random.uniform(min_,max_,size=[1000,1])
y_input = gen_y(x_input)[:, np.newaxis]
x_train,y_train,x_test,y_test = x_input[0:900,:],y_input[0:900,:],x_input[900:1000,:],y_input[900:1000,:]
#生成100个等差分布的节点
x_nodes = np.linspace(min_,max_,50).reshape((50,1))
y_nodes = gen_y(x_nodes)
rbf_ = rbf_bp(x_nodes,y_nodes,1.0)
rbf_.train(x_train,y_train,x_test,y_test,500,0.0001,1000)
pp = rbf_.predict(x_test[0:20],y_test[0:20])
if __name__ == "__main__":
main()