精华内容
下载资源
问答
  • 【机器学习】RBF神经网络原理与Python实现

    万次阅读 多人点赞 2018-11-24 19:51:20
    【机器学习】RBF神经网络原理与Python实现一、LSSVM数学原理1. 感知机2. SVM3. LSSVM4. LSSVM与SVM的区别二、LSSVM的python实现参考资料 一、LSSVM数学原理 1. 感知机 SVM是从感知机发展而来。假设有m个训练样本{...

    一、RBF神经网络原理

    1. RBF神经网络结构与RBF神经元

    RBF神经网络结构图
    RBF神经网络的结构图如上图所示,其结构与简单的BP神经网络相同都是三层网络结构:输入层、隐含层和输出层。不同的是,RBF神经网络的隐含层节点的激活函数为径向基(RBF)函数。
    假设训练数据集为 X = { x 1 , x 2 , ⋯   , x m } X = \left\{ {{x^1},{x^2}, \cdots ,{x^m}} \right\} X={x1,x2,,xm},其中第i个训练样本为 x i = { x 1 i , x 2 i , ⋯   , x n i } {x^i} = \left\{ {x_1^i,x_2^i, \cdots ,x_n^i} \right\} xi={x1i,x2i,,xni},也就是说样本数为m,特征数为n,所以输入层的节点个数为n。假设隐含层节点个数为s,第i个训练样本 x i {x^i} xi从隐含层的第j个节点( j = 1 , 2 , ⋯   , s j = 1,2, \cdots ,s j=1,2,,s)的输出为:

    G ( x i , c j ) = exp ⁡ ( − 1 2 ( σ j ) 2 ∥ x i − c j ∥ ) G\left( {{x^i},{c^j}} \right) = \exp \left( { - \frac{1}{{2{{\left( {{\sigma ^j}} \right)}^2}}}\left\| {{x^i} - {c^j}} \right\|} \right) G(xi,cj)=exp(2(σj)21xicj)

    其中 c j {c^j} cj σ j {\sigma ^j} σj分别是RBF神经网络第j个隐含层RBF激活函数的中心参数和宽度参数【参考资料1】。
    隐含层输出通过权重矩阵映射到输出层的输入,本博文中输出层节点的激励函数为线性函数( y = x y = x y=x)。

    RBF神经网络的数据流向为:训练样本—RBF隐含层—权重矩阵—输出层

    2. RBF神经网络求解

    RBF神经网络是BP神经网络的特殊形式,因此求解过程也与BP神经网络相同,分为两个部分:正向传播计算误差和反向传播调整参数。

    2.1 正向传播:计算误差

    对于样本 x i {x^i} xi,RBF神经网络的输出为 y i {y^i} yi

    y ^ i = ∑ j = 1 s w j G ( x i , c j ) {{\hat y}^i} = \sum\limits_{j = 1}^s {{w_j}G\left( {{x^i},{c^j}} \right)} y^i=j=1swjG(xi,cj)

    样本标签为 { y 1 , y 2 , ⋯   , y m } \left\{ {{y^1},{y^2}, \cdots ,{y^m}} \right\} {y1,y2,,ym},RBF神经网络的损失函数为:

    L o s s = 1 2 ∑ i = 1 m e i 2 = 1 2 ∑ i = 1 m ( y i − y ^ i ) 2 = 1 2 ∑ i = 1 m ( y i − ∑ j = 1 s w j G ( x i , c j ) ) 2 Loss = \frac{1}{2}\sum\limits_{i = 1}^m {{e_i}^2} = \frac{1}{2}{\sum\limits_{i = 1}^m {\left( {{y^i} - {{\hat y}^i}} \right)} ^2} = \frac{1}{2}{\sum\limits_{i = 1}^m {\left( {{y^i} - \sum\limits_{j = 1}^s {{w_j}G\left( {{x^i},{c^j}} \right)} } \right)} ^2} Loss=21i=1mei2=21i=1m(yiy^i)2=21i=1m(yij=1swjG(xi,cj))2

    2.2 反向传播:调整参数

    利用梯度下降法迭代求取 { c 1 , c 2 , ⋯   , c j } \left\{ {{c^1},{c^2}, \cdots ,{c^j}} \right\} {c1,c2,,cj} { σ 1 , σ 2 , ⋯   , σ j } \left\{ {{\sigma ^1},{\sigma ^2}, \cdots ,{\sigma ^j}} \right\} {σ1,σ2,,σj} { w 1 , w 2 , ⋯   , w j } \left\{ {{w_1},{w_2}, \cdots ,{w_j}} \right\} {w1,w2,,wj}【参考资料2】。

    c j = c j − α ∂ L o s s ∂ c j {c^j} = {c^j} - \alpha \frac{{\partial Loss}}{{\partial {c^j}}} cj=cjαcjLoss

    σ j = σ j − α ∂ L o s s ∂ σ j {\sigma ^j} = {\sigma ^j} - \alpha \frac{{\partial Loss}}{{\partial {\sigma ^j}}} σj=σjασjLoss

    w j = w j − α ∂ L o s s ∂ w j {w^j} = {w^j} - \alpha \frac{{\partial Loss}}{{\partial {w^j}}} wj=wjαwjLoss
    其求解过程为:
    { Δ c j = − α ∂ L o s s ∂ c j = α w j ( σ j ) 2 ∑ i = 1 m e i G ( x i , c j ) ( x i − c j ) Δ σ j = − α ∂ L o s s ∂ σ j = α w j ( σ j ) 3 ∑ i = 1 m e i G ( x i , c j ) ∥ x i − c j ∥ 2 Δ w j = − α ∂ L o s s ∂ w j = α ∑ i = 1 m e i G ( x i , c j ) \left\{ {\begin{matrix} {\Delta {c^j} = - \alpha \frac{{\partial Loss}}{{\partial {c^j}}} = \alpha \frac{{{w_j}}} {{{{\left( {{\sigma ^j}} \right)}^2}}}\sum\limits_{i = 1}^m {{e_i}G\left( {{x^i},{c^j}} \right)\left( {{x^i} - {c^j}} \right)} }\\ {\Delta {\sigma ^j} = - \alpha \frac{{\partial Loss}}{{\partial {\sigma ^j}}} = \alpha \frac{{{w_j}}}{{{{\left( {{\sigma ^j}} \right)}^3}}}\sum\limits_{i = 1}^m {{e_i}G\left( {{x^i},{c^j}} \right){{\left\| {{x^i} - {c^j}} \right\|}^2}} }\\ {\Delta {w_j} = - \alpha \frac{{\partial Loss}}{{\partial {w_j}}} = \alpha \sum\limits_{i = 1}^m {{e_i}G\left( {{x^i},{c^j}} \right)} } \end{matrix}} \right. Δcj=αcjLoss=α(σj)2wji=1meiG(xi,cj)(xicj)Δσj=ασjLoss=α(σj)3wji=1meiG(xi,cj)xicj2Δwj=αwjLoss=αi=1meiG(xi,cj)

    二、RBF神经网络的python实现

    代码及样本地址:https://github.com/shiluqiang/RBF_NN_Python
    RBF神经网络模型训练:

    // 
    from numpy import *
    from math import sqrt
    
    def load_data(file_name):
        '''导入数据
        input:  file_name(string):文件的存储位置
        output: feature_data(mat):特征
                label_data(mat):标签
                n_class(int):类别的个数
        '''
        # 1、获取特征
        f = open(file_name)  # 打开文件
        feature_data = []
        label = []
        for line in f.readlines():
            feature_tmp = []
            lines = line.strip().split("\t")
            for i in range(len(lines) - 1):
                feature_tmp.append(float(lines[i]))
            label.append(int(lines[-1]))      
            feature_data.append(feature_tmp)
        f.close()  # 关闭文件
        n_output = 1
        
        return mat(feature_data), mat(label).transpose(), n_output
    
    def linear(x):
        '''Sigmoid函数(输出层神经元激活函数)
        input:  x(mat/float):自变量,可以是矩阵或者是任意实数
        output: Sigmoid值(mat/float):Sigmoid函数的值
        '''
        return x
       
    
    def hidden_out(feature,center,delta):
        '''rbf函数(隐含层神经元输出函数)
        input:feature(mat):数据特征
              center(mat):rbf函数中心
              delta(mat):rbf函数扩展常数
        output:hidden_output(mat)隐含层输出
        '''
        m,n = shape(feature)
        m1,n1 = shape(center)
        hidden_out = mat(zeros((m,m1)))
        for i in range(m):
            for j in range(m1):
                hidden_out[i,j] = exp(-1.0 * (feature[i,:]-center[j,:]) * (feature[i,:]-center[j,:]).T/(2*delta[0,j]*delta[0,j]))        
        return hidden_out
    
    
    def predict_in(hidden_out, w):
        '''计算输出层的输入
        input:  hidden_out(mat):隐含层的输出
                w1(mat):隐含层到输出层之间的权重
                b1(mat):隐含层到输出层之间的偏置
        output: predict_in(mat):输出层的输入
        '''
        m = shape(hidden_out)[0]
        predict_in = hidden_out * w
        return predict_in
    
        
    def predict_out(predict_in):
        '''输出层的输出
        input:  predict_in(mat):输出层的输入
        output: result(mat):输出层的输出
        '''
        result = linear(predict_in)
        return result
    
    def bp_train(feature, label, n_hidden, maxCycle, alpha, n_output):
        '''计算隐含层的输入
        input:  feature(mat):特征
                label(mat):标签
                n_hidden(int):隐含层的节点个数
                maxCycle(int):最大的迭代次数
                alpha(float):学习率
                n_output(int):输出层的节点个数
        output: center(mat):rbf函数中心
                delta(mat):rbf函数扩展常数
                w(mat):隐含层到输出层之间的权重
        '''
        m, n = shape(feature)
        # 1、初始化
        center = mat(random.rand(n_hidden,n))
        center = center * (8.0 * sqrt(6) / sqrt(n + n_hidden)) - mat(ones((n_hidden,n))) * (4.0 * sqrt(6) / sqrt(n + n_hidden))
        delta = mat(random.rand(1,n_hidden))
        delta = delta * (8.0 * sqrt(6) / sqrt(n + n_hidden)) - mat(ones((1,n_hidden))) * (4.0 * sqrt(6) / sqrt(n + n_hidden))   
        w = mat(random.rand(n_hidden, n_output))
        w = w * (8.0 * sqrt(6) / sqrt(n_hidden + n_output)) - mat(ones((n_hidden, n_output))) * (4.0 * sqrt(6) / sqrt(n_hidden + n_output))
    
        
        # 2、训练
        iter = 0
        while iter <= maxCycle:
            # 2.1、信号正向传播
            # 2.1.1、计算隐含层的输出
            hidden_output = hidden_out(feature,center,delta)
            # 2.1.3、计算输出层的输入
            output_in = predict_in(hidden_output, w)  
            # 2.1.4、计算输出层的输出
            output_out = predict_out(output_in)
            
            # 2.2、误差的反向传播
            error = mat(label - output_out)
            for j in range(n_hidden):
                sum1 = 0.0
                sum2 = 0.0
                sum3 = 0.0
                for i in range(m):
                    sum1 += error[i,:] * exp(-1.0 * (feature[i]-center[j]) * (feature[i]-center[j]).T / (2 * delta[0,j]*delta[0,j])) * (feature[i] - center[j])
                    sum2 += error[i,:] * exp(-1.0 * (feature[i]-center[j]) * (feature[i]-center[j]).T / (2 * delta[0,j]*delta[0,j])) * (feature[i] - center[j]) * (feature[i] - center[j]).T
                    sum3 += error[i,:] * exp(-1.0 * (feature[i]-center[j]) * (feature[i]-center[j]).T / (2 * delta[0,j]*delta[0,j]))
                delta_center = (w[j,:]/(delta[0,j]*delta[0,j])) * sum1
                delta_delta = (w[j,:]/(delta[0,j]*delta[0,j]*delta[0,j])) * sum2
                delta_w = sum3
           # 2.3、 修正权重和rbf函数中心和扩展常数       
                center[j,:] = center[j,:] + alpha * delta_center
                delta[0,j] = delta[0,j] + alpha * delta_delta
                w[j,:] = w[j,:] + alpha * delta_w
            if iter % 10 == 0:
                cost = (1.0/2) * get_cost(get_predict(feature, center, delta, w) - label)
                print ("\t-------- iter: ", iter, " ,cost: ",  cost)
            if cost < 3:   ###如果损失函数值小于3则停止迭
                break               
            iter += 1           
        return center, delta, w
    
    def get_cost(cost):
        '''计算当前损失函数的值
        input:  cost(mat):预测值与标签之间的差
        output: cost_sum / m (double):损失函数的值
        '''
        m,n = shape(cost)
        
        cost_sum = 0.0
        for i in range(m):
            for j in range(n):
                cost_sum += cost[i,j] * cost[i,j]
        return cost_sum / m
    
    def get_predict(feature, center, delta, w):
        '''计算最终的预测
        input:  feature(mat):特征
                w0(mat):输入层到隐含层之间的权重
                b0(mat):输入层到隐含层之间的偏置
                w1(mat):隐含层到输出层之间的权重
                b1(mat):隐含层到输出层之间的偏置
        output: 预测值
        '''
        return predict_out(predict_in(hidden_out(feature,center,delta), w))
    
    def save_model_result(center, delta, w, result):
        '''保存最终的模型
        input:  w0(mat):输入层到隐含层之间的权重
                b0(mat):输入层到隐含层之间的偏置
                w1(mat):隐含层到输出层之间的权重
                b1(mat):隐含层到输出层之间的偏置
        output: 
        '''
        def write_file(file_name, source):   
            f = open(file_name, "w")
            m, n = shape(source)
            for i in range(m):
                tmp = []
                for j in range(n):
                    tmp.append(str(source[i, j]))
                f.write("\t".join(tmp) + "\n")
            f.close()
        
        write_file("center.txt", center)
        write_file("delta.txt", delta)
        write_file("weight.txt", w)
        write_file('train_result.txt',result)
        
    def err_rate(label, pre):
        '''计算训练样本上的错误率
        input:  label(mat):训练样本的标签
                pre(mat):训练样本的预测值
        output: rate[0,0](float):错误率
        '''
        
        m = shape(label)[0]
        for j in range(m):
            if pre[j,0] > 0.5:
                pre[j,0] = 1.0
            else:
                pre[j,0] = 0.0
    
        err = 0.0
        for i in range(m):
            if float(label[i, 0]) != float(pre[i, 0]):
                err += 1
        rate = err / m
        return rate
    
    if __name__ == "__main__":
        # 1、导入数据
        print ("--------- 1.load data ------------")
        feature, label, n_output = load_data("data.txt")
        # 2、训练网络模型
        print ("--------- 2.training ------------")
        center, delta, w = bp_train(feature, label, 20, 5000, 0.008, n_output)
        # 3、得到最终的预测结果
        print ("--------- 3.get prediction ------------")
        result = get_predict(feature, center, delta, w)    
        print ("训练准确性为:", (1 - err_rate(label, result)))
        # 4、保存最终的模型
        print ("--------- 4.save model and result ------------")
        save_model_result(center, delta, w, result)
    

    RBF神经网络模型测试:

    //
    from numpy import * 
    from RBF_TRAIN import get_predict
    
    def load_data(file_name):
        '''导入数据
        input:  file_name(string):文件的存储位置
        output: feature_data(mat):特征
        '''
        f = open(file_name)  # 打开文件
        feature_data = []
        for line in f.readlines():
            feature_tmp = []
            lines = line.strip().split("\t")
            for i in range(len(lines)):
                feature_tmp.append(float(lines[i]))        
            feature_data.append(feature_tmp)
        f.close()  # 关闭文件
        return mat(feature_data)
    
    def generate_data():
        '''在[-4.5,4.5]之间随机生成20000组点
        '''
        # 1、随机生成数据点
        data = mat(zeros((20000, 2)))
        m = shape(data)[0]
        x = mat(random.rand(20000, 2))
        for i in range(m):
            data[i, 0] = x[i, 0] * 9 - 4.5
            data[i, 1] = x[i, 1] * 9 - 4.5
        # 2、将数据点保存到文件“test_data”中
        f = open("test_data.txt", "w")
        m,n = shape(data)
        for i in range(m):
            tmp =[]
            for j in range(n):
                tmp.append(str(data[i,j]))
            f.write("\t".join(tmp) + "\n")
        f.close()       
    
    def load_model(file_center, file_delta, file_w):
        
        def get_model(file_name):
            f = open(file_name)
            model = []
            for line in f.readlines():
                lines = line.strip().split("\t")
                model_tmp = []
                for x in lines:
                    model_tmp.append(float(x.strip()))
                model.append(model_tmp)
            f.close()
            return mat(model)
        
        # 1、导入rbf函数中心
        center = get_model(file_center)
        
        # 2、导入rbf函数扩展常数
        delta = get_model(file_delta)
        
        # 3、导入隐含层到输出层之间的权重
        w = get_model(file_w)
    
    
        return center, delta, w
    
    def save_predict(file_name, pre):
        '''保存最终的预测结果
        input:  pre(mat):最终的预测结果
        output:
        '''
        f = open(file_name, "w")
        m = shape(pre)[0]
        result = []
        for i in range(m):
            result.append(str(pre[i, 0]))
        f.write("\n".join(result))
        f.close()
    
    if __name__ == "__main__":
        generate_data()
        # 1、导入测试数据
        print ("--------- 1.load data ------------")
        dataTest = load_data("test_data.txt")
        # 2、导入BP神经网络模型
        print ("--------- 2.load model ------------")
        center,delta,w = load_model("center.txt", "delta.txt", "weight.txt")
        # 3、得到最终的预测值
        print ("--------- 3.get prediction ------------")
        result = get_predict(dataTest, center, delta, w)
        # 4、保存最终的预测结果
        print ("--------- 4.save result ------------")
        save_predict("test_result.txt", result)
    

    参考资料

    【1】https://www.cnblogs.com/pinking/p/9349695.html
    【2】https://www.cnblogs.com/zhangchaoyang/articles/2591663.html

    展开全文
  • 遗传算法优化RBF神经网络代码,十分详细,通俗易懂,可供阅读与学习
  • RBF神经网络自适应控制MATLAB仿真介绍了RBF神经网络原理和方法,列举了很多的控制例子,并且给出了详细的MATLAB程序代码,按照代码可以复现书中的仿真程序。
  • RBF神经网络简单介绍与MATLAB实现

    万次阅读 多人点赞 2017-05-30 09:10:02
    MATLAB实现RBF神经网络 RBF的直观介绍RBF具体原理,网络上很多文章一定讲得比我好,所以我也不费口舌了,这里只说一说对RBF网络的一些直观的认识1 RBF是一种两层的网络是的,RBF结构上并不复杂,只

    RBF的直观介绍

    RBF具体原理,网络上很多文章一定讲得比我好,所以我也不费口舌了,这里只说一说对RBF网络的一些直观的认识

    1 RBF是一种两层的网络

    是的,RBF结构上并不复杂,只有两层:隐层和输出层。其模型可以数学表示为:
    y j = ∑ i = 1 n w i j ϕ ( ∥ x − u i ∥ 2 ) , ( j = 1 , … , p ) y_j = \sum_{i=1}^n w_{ij} \phi(\Vert x - u_i\Vert^2), (j = 1,\dots,p) yj=i=1nwijϕ(xui2),(j=1,,p)
    在这里插入图片描述
    在这里插入图片描述

    2 RBF的隐层是一种非线性的映射

    RBF隐层常用激活函数是高斯函数:
    ϕ ( ∥ x − u ∥ ) = e − ∥ x − u ∥ 2 σ 2 \phi(\Vert x - u\Vert) = e^{-\frac{\Vert x-u\Vert^2}{\sigma^2}} ϕ(xu)=eσ2xu2

    3 RBF输出层是线性的

    4 RBF的基本思想是:将数据转化到高维空间,使其在高维空间线性可分

    RBF隐层将数据转化到高维空间(一般是高维),认为存在某个高维空间能够使得数据在这个空间是线性可分的。因此啊,输出层是线性的。这和核方法的思想是一样一样的。下面举个老师PPT上的例子:
    在这里插入图片描述

    上面的例子,就将原来的数据,用高斯函数转换到了另一个二维空间中。在这个空间里,XOR问题得到解决。可以看到,转换的空间不一定是比原来高维的。

    RBF学习算法

    在这里插入图片描述

    对于上图的RBF网络,其未知量有:中心向量 u i u_i ui,高斯函数中常数 σ \sigma σ,输出层权值 W W W
    学习算法的整个流程大致如下图:
    在这里插入图片描述

    具体可以描述为:

    1. 利用kmeans算法寻找中心向量 u i u_i ui
    2. 利用kNN(K nearest neighbor)rule 计算 σ \sigma σ
      σ i = 1 K ∑ k = 1 K ∥ u k − u i ∥ 2 \sigma_i = \sqrt{\frac{1}{K}\sum_{k=1}^K \Vert u_k - u_i\Vert^2} σi=K1k=1Kukui2
    3. W W W可以利用最小二乘法求得

    Lazy RBF

    可以看到原来的RBF挺麻烦的,又是kmeans又是knn。后来就有人提出了lazy RBF,就是不用kmeans找中心向量了,将训练集的每一个数据都当成是中心向量。这样的话,核矩阵 Φ \Phi Φ就是一个方阵,并且只要保证训练中的数据是不同的,核矩阵 Φ \Phi Φ就是可逆的。这种方法确实lazy,缺点就是如果训练集很大,会导致核矩阵 Φ \Phi Φ也很大,并且要保证训练集个数要大于每个训练数据的维数。
    在这里插入图片描述

    MATLAB实现RBF神经网络

    下面实现的RBF只有一个输出,供大家参考参考。对于多个输出,其实也很简单,就是 W W W变成了多个,这里就不实现了。

    demo.m 对XOR数据进行了RBF的训练和预测,展现了整个流程。最后的几行代码是利用封装形式进行训练和预测。

    clc;
    clear all;
    close all;
    
    %% ---- Build a training set of a similar version of XOR
    c_1 = [0 0];
    c_2 = [1 1];
    c_3 = [0 1];
    c_4 = [1 0];
    
    n_L1 = 20; % number of label 1
    n_L2 = 20; % number of label 2
    
    
    A = zeros(n_L1*2, 3);
    A(:,3) = 1;
    B = zeros(n_L2*2, 3);
    B(:,3) = 0;
    
    % create random points
    for i=1:n_L1
       A(i, 1:2) = c_1 + rand(1,2)/2;
       A(i+n_L1, 1:2) = c_2 + rand(1,2)/2;
    end
    for i=1:n_L2
       B(i, 1:2) = c_3 + rand(1,2)/2;
       B(i+n_L2, 1:2) = c_4 + rand(1,2)/2;
    end
    
    % show points
    scatter(A(:,1), A(:,2),[],'r');
    hold on
    scatter(B(:,1), B(:,2),[],'g');
    X = [A;B];
    data = X(:,1:2);
    label = X(:,3);
    
    %% Using kmeans to find cinter vector
    n_center_vec = 10;
    rng(1);
    [idx, C] = kmeans(data, n_center_vec);
    hold on
    scatter(C(:,1), C(:,2), 'b', 'LineWidth', 2);
    
    %% Calulate sigma 
    n_data = size(X,1);
    
    % calculate K
    K = zeros(n_center_vec, 1);
    for i=1:n_center_vec
       K(i) = numel(find(idx == i)); 
    end
    
    % Using knnsearch to find K nearest neighbor points for each center vector
    % then calucate sigma
    sigma = zeros(n_center_vec, 1);
    for i=1:n_center_vec
        [n, d] = knnsearch(data, C(i,:), 'k', K(i));
        L2 = (bsxfun(@minus, data(n,:), C(i,:)).^2);
        L2 = sum(L2(:));
        sigma(i) = sqrt(1/K(i)*L2);
    end
    
    %% Calutate weights
    % kernel matrix
    k_mat = zeros(n_data, n_center_vec);
    
    for i=1:n_center_vec
       r = bsxfun(@minus, data, C(i,:)).^2;
       r = sum(r,2);
       k_mat(:,i) = exp((-r.^2)/(2*sigma(i)^2));
    end
    
    W = pinv(k_mat'*k_mat)*k_mat'*label;
    y = k_mat*W;
    %y(y>=0.5) = 1;
    %y(y<0.5) = 0;
    
    %% training function and predict function
    [W1, sigma1, C1] = RBF_training(data, label, 10);
    y1 = RBF_predict(data, W, sigma, C1);
    [W2, sigma2, C2] = lazyRBF_training(data, label, 2);
    y2 = RBF_predict(data, W2, sigma2, C2);
    

    在这里插入图片描述

    上图是XOR训练集。其中蓝色的kmenas选取的中心向量。中心向量要取多少个呢?这也是玄学问题,总之不要太少就行,代码中取了10个,但是从结果 y y y来看,其实对于XOR问题来说,4个就可以了。

    RBF_training.m 对demo.m中训练的过程进行封装

    function [ W, sigma, C ] = RBF_training( data, label, n_center_vec )
    %RBF_TRAINING Summary of this function goes here
    %   Detailed explanation goes here
    
        % Using kmeans to find cinter vector
        rng(1);
        [idx, C] = kmeans(data, n_center_vec);
        
        % Calulate sigma 
        n_data = size(data,1);
        
        % calculate K
        K = zeros(n_center_vec, 1);
        for i=1:n_center_vec
            K(i) = numel(find(idx == i));
        end
        
        % Using knnsearch to find K nearest neighbor points for each center vector
        % then calucate sigma
        sigma = zeros(n_center_vec, 1);
        for i=1:n_center_vec
            [n] = knnsearch(data, C(i,:), 'k', K(i));
            L2 = (bsxfun(@minus, data(n,:), C(i,:)).^2);
            L2 = sum(L2(:));
            sigma(i) = sqrt(1/K(i)*L2);
        end
        % Calutate weights
        % kernel matrix
        k_mat = zeros(n_data, n_center_vec);
        
        for i=1:n_center_vec
            r = bsxfun(@minus, data, C(i,:)).^2;
            r = sum(r,2);
            k_mat(:,i) = exp((-r.^2)/(2*sigma(i)^2));
        end
        
        W = pinv(k_mat'*k_mat)*k_mat'*label;
    end
    
    

    RBF_lazytraning.m 对lazy RBF的实现,主要就是中心向量为训练集自己,然后再构造核矩阵。由于 Φ \Phi Φ一定可逆,所以在求逆时,可以使用快速的’\‘方法

    function [ W, sigma, C ] = lazyRBF_training( data, label, sigma )
    %LAZERBF_TRAINING Summary of this function goes here
    %   Detailed explanation goes here
        if nargin < 3
           sigma = 1; 
        end
    
        n_data = size(data,1);
        C = data;
        
        % make kernel matrix
        k_mat = zeros(n_data);
        for i=1:n_data
           L2 = sum((data - repmat(data(i,:), n_data, 1)).^2, 2);
           k_mat(i,:) = exp(L2'/(2*sigma));
        end
        
        W = k_mat\label;
    end
    
    

    RBF_predict.m 预测

    function [ y ] = RBF_predict( data, W, sigma, C )
    %RBF_PREDICT Summary of this function goes here
    %   Detailed explanation goes here
        n_data = size(data, 1);
        n_center_vec = size(C, 1);
        if numel(sigma) == 1
           sigma = repmat(sigma, n_center_vec, 1);
        end
        
        % kernel matrix
        k_mat = zeros(n_data, n_center_vec);
        for i=1:n_center_vec
            r = bsxfun(@minus, data, C(i,:)).^2;
            r = sum(r,2);
            k_mat(:,i) = exp((-r.^2)/(2*sigma(i)^2));
        end
        
        y = k_mat*W;
    end
    
    
    展开全文
  • RBF神经网络中心选取OLS算法的研究-RBF神经网络中心选取OLS算法的研究.rar RBF神经网络中心选取OLS算法的研究。好东西哦 刘文菊,郭 景 摘 要:介绍了RBF网络的基本原理,对RBF网络中心选取的算法进行了研究...
  • RBF神经网络理论与实现

    万次阅读 多人点赞 2020-11-02 18:46:51
    最近发现有挺多人喜欢径向基函数(Radial Basis Function,RBF)神经网络,其实它就是将RBF作为神经网络层间的一种连接方式而已。这里做一个简单的描述和找了个代码解读。 之前也写过一篇,不过排版不好看,可以戳这里...

    前言

    最近发现有挺多人喜欢径向基函数(Radial Basis Function,RBF)神经网络,其实它就是将RBF作为神经网络层间的一种连接方式而已。这里做一个简单的描述和找了个代码解读。
    之前也写过一篇,不过排版不好看,可以戳这里跳转

    国际惯例,参考博客:

    理论

    基本思想

    RBF作为隐单元的“基”构成隐藏层空间,隐藏层对输入矢量进行变换,将低维的模式输入数据变换到高维空间内,使得在低维空间内的线性不可分问题在高维空间内线性可分。

    详细一点就是用RBF的隐单元的“基”构成隐藏层空间,这样就可以将输入矢量直接(不通过权连接)映射到隐空间。当RBF的中心点确定以后,这种映射关系也就确定 了。而隐含层空间到输出空间的映射是线性的(注意这个地方区分一下线性映射和非线性映射的关系),即网络输出是隐单元输出的线性加权和,此处的权即为网络可调参数。

    径向基神经网络的节点激活函数采用径向基函数,定义了空间中任一点到某一中心点的欧式距离的单调函数。

    我们通常使用的函数是高斯函数:
    ϕ ( r ) = e − ( ϵ r ) 2 \phi(r) = e^{-(\epsilon r)^2} ϕ(r)=e(ϵr)2
    在《Phase-Functioned Neural Networks for Character Control》论文代码中有提到很多径向基函数:

    kernels = {
        'multiquadric': lambda x: np.sqrt(x**2 + 1),
        'inverse':      lambda x: 1.0 / np.sqrt(x**2 + 1),
        'gaussian':     lambda x: np.exp(-x**2),
        'linear':       lambda x: x,
        'quadric':      lambda x: x**2,
        'cubic':        lambda x: x**3,
        'quartic':      lambda x: x**4,
        'quintic':      lambda x: x**5,
        'thin_plate':   lambda x: x**2 * np.log(x + 1e-10),
        'logistic':     lambda x: 1.0 / (1.0 + np.exp(-np.clip(x, -5, 5))),
        'smoothstep':   lambda x: ((np.clip(1.0 - x, 0.0, 1.0))**2.0) * (3 - 2*(np.clip(1.0 - x, 0.0, 1.0)))
    }
    

    下图是径向基神经元模型

    在这里插入图片描述

    径向基函数的激活函数是以输入向量和权值向量(注意此处的权值向量并非隐藏层到输出层的权值,具体看下面的径向基神经元模型结构)之间的距离||dist||作为自变量的,图中的b为阈值,用于调整神经元的灵敏度。径向基网络的激活函数的一般表达式为
    R ( ∥ d i s t ∥ ) = e − ∥ d i s t ∥ R(\parallel dist \parallel) = e^{-\parallel dist \parallel} R(dist)=edist
    下图是以高斯核为径向基函数的神经元模型:

    在这里插入图片描述

    对应到激活函数表达式:
    R ( x p − c i ) = exp ⁡ ( − 1 2 σ 2 ∥ x p − c i ∥ 2 ) R(x_p-c_i)=\exp{\left(-\frac{1}{2\sigma^2}\parallel x_p - c_i \parallel^2 \right)} R(xpci)=exp(2σ21xpci2)
    其中X代表输入向量,C代表权值,为高斯函数的中心, σ \sigma σ是高斯函数的方差,可以用来调整影响半径(仔细想想高斯函数中 c c c σ \sigma σ调整后对函数图的影响);当权值和输入向量的距离越小,网络的输出不断递增,输入向量越靠近径向基函数的中心,隐层节点产生的输出越大。也就是说径向基函数对输入信号在局部产生响应,输入向量与权值距离越远,隐层输出越接近0,再经过一层线性变换映射到最终输出层,导致输出层也接近0。

    结构

    RBF是具有单隐层的三层前向网络。

    在这里插入图片描述

    • 第一层为输入层,由信号源节点组成。

    • 第二层为隐藏层,隐藏层节点数视所描述问题的需要而定,隐藏层中神经元的变换函数即径向基函数是对中心点径向对称且衰减的非负线性函数,该函数是局部响应函数,具体的局部响应体现在其可见层到隐藏层的变换是通过径向基函数计算,跟其它的网络不同。以前的前向网络变换函数都是全局响应的函数。

    • 第三层为输出层,是对输入模式做出的响应。

    输入层仅仅起到传输信号作用,输入层和隐含层之间可以看做连接权值为1的连接,输出层与隐含层所完成的任务是不同的,因而他们的学习策略也不同。输出层是对线性权进行调整,采用的是线性优化策略,因而学习速度较快;而隐含层是对激活函数(格林函数,高斯函数,一般取后者)的参数进行调整,采用的是非线性优化策略,因而学习速度较慢。

    参数

    径向基函数需要两组参数:

    • 基函数中心
    • 方差(宽度)

    隐层到输出层只需要一组参数:

    • 权值

    优点

    • 逼近能力,分类能力和学习速度等方面都优于BP神经网络
    • 结构简单、训练简洁、学习收敛速度快、能够逼近任意非线性函数
    • 克服局部极小值问题。原因在于其参数初始化具有一定的方法,并非随机初始化。

    缺点

    • 如果中心点是样本中的数据,就并不能反映出真实样本的状况,那么输入到隐层的映射就是不准确的
    • 如果使用有监督学习,函数中心是学习到的,但是如果中心点选取不当,就会导致不收敛。

    各层的计算

    首先初始化参数:中心、宽度、权值

    不同隐含层神经元的中心应有不同的取值,并且与中心的对应宽度能够调节,使得不同的输入信息特征能被不同的隐含层神经元最大的反映出来,在实际应用时,一个输入信息总是包含在一定的取值范围内。

    中心

    • 方法1

      《模式识别与智能计算》中介绍了一种方法:将隐含层各神经元的中心分量的初值,按从小到大等间距变化,使较弱的输入信息在较小的中心附近产生较强的响应。间距的大小可由隐藏层神经元的个数来调节。好处是能够通过试凑的方法找到较为合理的隐含层神经元数,并使中心的初始化尽量合理,不同的输入特征更为明显地在不同的中心处反映出来,体现高斯核的特点:
      c j i = min ⁡ i + max ⁡ i − min ⁡ i 2 p + ( j − 1 ) max ⁡ i − min ⁡ i p c_{ji} = \min i + \frac{\max i-\min i}{2p}+(j-1)\frac{\max i-\min i}{p} cji=mini+2pmaximini+(j1)pmaximini
      其中p为隐层神经元总个数,j为隐层神经元索引,i为输入神经元索引, max ⁡ i \max i maxi是训练集中第i个特征所有输入信息的最小值,$\max i $为训练集中第i个特征所有输入信息的最大值。

    • 方法2
      《43案例分析》中介绍的是Kmean使用方法,就是传统的算法,先随机选k个样本作为中心,然后按照欧氏距离对每个样本分组,再重新确定聚类中心,再不断重复上面的步骤,直到最终聚类中心变化在一定范围内。

    宽度

    宽度向量影响着神经元对输入信息的作用范围:宽度越小,相应隐含层神经元作用函数的形状越窄,那么处于其他神经元中心附近的信息在该神经元出的响应就越小;就跟高斯函数图像两边的上升下降区域的宽度一样。按照《模式识别与智能计算》,计算有点像标准差的计算(但是此处原文没有带平方,不过我觉得应该带上,详细可以查阅这个YouTube视频,不带平方,万一出现负数是无法求根的):
    d j i = d f 1 N ∑ k = 1 N ( x i k − c j i ) 2 d_{ji}= d_f\sqrt{\frac{1}{N}\sum_{k=1}^N(x_i^k-c_{ji})^2} dji=dfN1k=1N(xikcji)2
    当然也可以用《43案例分析》里面说的,利用中心之间的最大距离 c m a x c_{max} cmax去计算,其中h是聚类中心个数:
    d = c m a x 2 h d = \frac{c_{max}}{\sqrt{2h}} d=2h cmax

    输入层到隐层的计算

    直接套入到选择的径向基函数中:
    z j = exp ⁡ ( − ∣ ∣ X − C j D j ∣ ∣ 2 ) z_j = \exp\left(- \left|\left|\frac{X-C_j}{D_j} \right|\right|^2\right) zj=exp(DjXCj2)
    其中 C j C_j Cj就是第j个隐层神经元对应的中心向量,由隐层第j个神经元所连接的输入层所有神经元的中心分量构成,即 C j = [ C j 1 , C j 2 , ⋯   , C j n ] C_j = [C_{j1},C_{j2},\cdots,C_{jn}] Cj=[Cj1,Cj2,,Cjn] D j D_j Dj为隐层第j个神经元的宽度向量,与 C j C_j Cj对应, D j D_j Dj越大,隐层对输入向量的影响范围就越大,而且神经元间的平滑程度就更好。

    隐层到输出层的计算

    就是传统的神经网络里面,把核函数去掉,变成了线性映射关系:
    y k = ∑ j = 1 p w k j z j y_k = \sum_{j=1}^p w_{kj}z_j yk=j=1pwkjzj
    其中k是输出层神经元个数。

    权重迭代

    直接使用梯度下降法训练,中心、宽度、权重都通过学习来自适应调节更新。
    在这里插入图片描述

    其中 η \eta η为学习率, E E E为损失函数,一般就是均方差。

    训练步骤

    • 先初始化中心、宽度、最后一层权重
    • 计算损失,如果在接受范围内,停止训练
    • 利用梯度更新的方法更新中心、宽度、权重
    • 返回第二步

    代码实现

    有大佬利用keras实现过基于Kmeans的高斯RBF神经网络层,代码戳这里

    首先利用sklearn里面的库构建一个K-means

    from keras.initializers import Initializer
    from sklearn.cluster import KMeans
    
    
    class InitCentersKMeans(Initializer):
        """ Initializer for initialization of centers of RBF network
            by clustering the given data set.
        # Arguments
            X: matrix, dataset
        """
    
        def __init__(self, X, max_iter=100):
            self.X = X
            self.max_iter = max_iter
    
        def __call__(self, shape, dtype=None):
            assert shape[1] == self.X.shape[1]
    
            n_centers = shape[0]
            km = KMeans(n_clusters=n_centers, max_iter=self.max_iter, verbose=0)
            km.fit(self.X)
            return km.cluster_centers_
    

    构建RBF层的时候,第一层初始化使用上面的Kmeans初始化

    self.centers = self.add_weight(name='centers',
                                   shape=(self.output_dim, input_shape[1]),
                                   initializer=self.initializer,
                                   trainable=True)
    

    第二层用一个线性加权的层

    self.betas = self.add_weight(name='betas',
                                 shape=(self.output_dim,),
                                 initializer=Constant(
                                     value=self.init_betas),
                                 # initializer='ones',
                                 trainable=True)
    
    

    计算时候:

    def call(self, x):
            C = K.expand_dims(self.centers)
            H = K.transpose(C-K.transpose(x))
            return K.exp(-self.betas * K.sum(H**2, axis=1))
    

    但是此处我觉得有问题,这里的宽度向量好像没有体现出来,所以我重写了一个:

    def call(self, x):
         C = K.expand_dims(self.centers)
         XC = K.transpose(K.transpose(x)-C)     
         D = K.expand_dims(K.sqrt(K.mean(XC**2,axis=0)),0) 
         H = XC/D
         return K.exp(-self.betas * K.sum(H**2, axis=1))
    

    可以看原作者的代码,作者是用于二维数据的拟合;

    也可以看我的代码,基于原作者代码,做的二维数据分类

    在这里插入图片描述
    小点为训练集,大圆点为测试集

    后记

    RBF可以用于插值、分类;在论文《Phase-Functioned Neural Networks for Character Control》还用来更改地形,也就是说图形、图像通用,说明还是蛮重要的。这里主要介绍了一下理论,后续再去做扩展性研究。

    完整的python脚本实现放在微信公众号的简介中描述的github中,有兴趣可以去找找,同时文章也同步到微信公众号中,有疑问或者兴趣欢迎公众号私信。
    在这里插入图片描述

    展开全文
  • RBF神经网络的PID控制

    2018-07-05 11:05:10
    通过MATLAB的M文件来实现基于RBF神经网络的PID控制,包括作图
  • RBF_神经网络及其应用

    2018-02-28 22:40:12
    介绍了径向基函数(RBF)神经网络原理、学习算法及其在地震预报专家系统ESEP 3. 0 中的应用。实际应用结果表明, 该神经网络可以很好地克服BP 神经网络学习过程的收敛过分 依赖于初值和可能出现局部收敛的缺陷, 具有...
  • RBF神经网络和拟合实例

    千次阅读 2020-09-12 21:59:07
    RBF神经网络及拟合实例RBF神经网络介绍RBF神经网络结构RBF神经网络算法RBF神经网络逼近算法采用RBF神经网络逼近非线性函数神经网络逼近结果代码如下 RBF神经网络介绍 RBF神经网络结构 径向基函数(Radial Basis ...

    RBF神经网络介绍

    RBF神经网络结构

    径向基函数(Radial Basis Function, RBF)神经网络是一种单隐含层的三层前馈神经网络,网络结构如下图所示
    在这里插入图片描述
    RBF神经网络模拟了人脑中局部调整,相互覆盖接受域(或者说感受域,Receptive Field)的神经网络结构。与BP神经网络相同,研究人员已经证明RBF神经网络能够以任何精度逼近任意非线性函数。

    RBF神经网络算法

    便于分析,记RBF神经网络的输入为m维,隐含层有 s 1 s_1 s1个神经元,输出层有 s 2 s_2 s2个神经元。
    RBF神经网络隐含层神经元的激活函数为如下所示的高斯基函数
    h j = exp ⁡ ( − ∣ ∣ x − c j ∣ ∣ 2 2 b j 2 ) , j = 1 , 2 , . . . , s 1 h_j = \exp(-\frac{||\bm{x}-\bm{c}_j||^2}{2b_j^2}),j=1,2,...,s_1 hj=exp(2bj2xcj2),j=1,2,...,s1
    其中, c j = [ c j 1 , c j 2 , . . . , c j m ] T \bm{c}_j=[c_{j1},c_{j2},...,c_{jm}]^T cj=[cj1,cj2,...,cjm]T为第j个隐含层神经元高斯基函数的中心向量, m m m表示网络输入 x \bm{x} x的维数, b j b_j bj为第j个隐含层神经元高斯基函数的宽度。与之前提及的BP神经网络中的sigmod函数不同,高斯基函数只在有限的范围内,输入是非零的,超过一定的范围,其输出则为零。
    在一维情况下,不同的 c j \bm{c}_j cj b j b_j bj对高斯基函数的影响如下图所示
    在这里插入图片描述
    可以看到, b j b_j bj越大,高斯基函数的非零输出区域越大,表明对输入的映射能力越强。 c j \bm{c_j} cj表示非零输出区域的中心位置,输入离中心越近,其输出值会更大,表明高斯基函数对输入更加敏感。
    RBF神经网络的输出为
    y = W H \bm{y} = \bm{WH} y=WH
    其中, W ∈ R s 2 × s 1 \bm{W}\in R^{s_2 \times {s_1}} WRs2×s1为RBF神经网络输出层权值矩阵, H ∈ R s 1 H \in R^{s_1} HRs1为隐含层输出, H = [ h 1 , h 2 , . . . , h s 1 ] T \bm{H} = [h_1,h_2,...,h_{s_1}]^T H=[h1,h2,...,hs1]T

    RBF神经网络逼近算法

    相较BP神经网络,RBF神经网络结构更加简单,同时需要调节的参数也更少,只有输出层的权值矩阵 W \bm{W} W需要在训练过程中调节。与BP神经网络类似,我们可以以采用梯度下降法来调节权值矩阵。
    定义RBF神经网络的估计误差指标为
    E = 1 2 ∑ i = 1 s 2 ∣ ∣ e i ∣ ∣ 2 = 1 2 ∑ i = 1 s 2 ∣ ∣ y d − y ∣ ∣ 2 E =\frac{1}{2}\sum_{i=1}^{s_2}||e_i||^2= \frac{1}{2} \sum_{i=1}^{s_2}|| \bm{y_d}-\bm{y}||^2 E=21i=1s2ei2=21i=1s2ydy2
    其中, y d \bm{y_d} yd为期望输出。
    对误差指标关于输出层权值矩阵 W \bm{W} W中元素进行求导得到
    ∂ E ∂ W i 0 = ∂ E ∂ e i ∂ e i ∂ y i ∂ y i ∂ W i 0 = − e i h i \frac{\partial E}{\partial W_{i0}}=\frac{\partial E}{\partial e_i} \frac{\partial e_i}{\partial y_i} \frac{\partial y_i}{\partial W_{i0}}=-e_ih_i Wi0E=eiEyieiWi0yi=eihi
    那么,权值可按如下方式调节
    Δ W i 0 = − η e i h i W i 0 ( k + 1 ) = W i 0 ( k ) + Δ W i 0 + α ( W i 0 ( k − 1 ) − W i 0 ( k − 2 ) ) \Delta W_{i0} = -\eta e_ih_i \\ W_{i0}(k+1) = W_{i0}(k)+\Delta W_{i0} + \alpha (W_{i0}(k-1)-W_{i0}(k-2)) ΔWi0=ηeihiWi0(k+1)=Wi0(k)+ΔWi0+α(Wi0(k1)Wi0(k2))
    其中, η ∈ ( 0 , 1 ) \eta\in(0,1) η(0,1)为学习速度, α ∈ ( 0 , 1 ) \alpha \in(0,1) α(0,1)为动量因子。

    采用RBF神经网络逼近非线性函数

    采用RBF神经网络,逼近简单的正弦函数
    y = s i n ( t ) y=sin(t) y=sin(t)
    可知,采用的RBF神经网络输入和输出层神经元数量都为1,设置隐含层神经元数量为10个。
    由于RBF神经网络采用的激活函数在有限区域内输出为非零,因此在设计RBF神经网络的时候,需要根据网络的输入来确定每个隐含层神经元激活函数的参数,即 c j c_j cj b j b_j bj。合适的网络参数能够提升网络的逼近效果和性能,而不合适的参数会导致神经网络训练失败,或者达不到想要的效果。
    通常来说, c j c_j cj参数需要与网络的输入相匹配,要保证输入在高斯基函数的有效映射区域内;同样的,根据输入的范围和高斯基函数的中心,来设置一个合适的宽度参数 b j b_j bj
    在本例中,神经网络的输入为时间 t ∈ [ 0 , 10 ] t \in[0,10] t[0,10],因此取径向基函数中心和宽度为
    C = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] T B = [ b j ] 10 × 1 , b j = 1 , j = 1 , 2 , . . . 10 \bm{C} = [1,2,3,4,5,6,7,8,9,10] ^T \\ \bm{B} = [b_j]_{10\times 1},b_j = 1,j=1,2,...10 C=[1,2,3,4,5,6,7,8,9,10]TB=[bj]10×1,bj=1,j=1,2,...10

    神经网络逼近结果

    训练过程中误差收敛情况如下所示
    在这里插入图片描述
    将训练得到的神经网络进行验证
    在这里插入图片描述

    代码如下

    %训练简单的RBF神经网络来拟合非线性函数
    clear,clc
    %% 生成训练数据
    ts = 0.01;
    u1 = 0;
    y1 = 0;
    
    for k=1:1000
        u(k) = k*ts;
        y(k) = sin(u(k));
    end
    len = length(u);
    %% RBFNN初始设置
    % RBFNN结构为1-10-1
    n = 1;
    s1 = 10;
    s2 = 1;
    c = (1:1:10);    %高斯基函数中心
    b = ones(s1,1).*2;    %高斯基函数宽度
    W = rand(s2,s1);   %输出权值矩阵
    DW = zeros(s2,s1);
    Wt1 = zeros(s2,s1); %上一时刻权值阵
    Wt2 = zeros(s2,s1); %上上时刻权值阵
    H = zeros(s1,1);    %隐含层输出
    m = 500;
    Error = zeros(m,s2);
    %% 训练算法
    e_tol = 1e-4;
    irt_max = 20000;
    e = ones(irt_max,1);
    eta = 0.3;
    alpha = 0.1;
    for cnt = 1:irt_max
        idx_rand = randperm(1000);
        u_train = u(idx_rand);
        y_train = y(idx_rand);
        % 前向计算
        for i = 1:m
           x = u_train(i);
           for j = 1:s1
              H(j) = exp(-(x-c(j))^2/(2*b(j)^2));    %隐含层计算
           end
           y_etm = dot(W,H);     %神经网络预测值
           Error(i) = y_train(i) - y_etm;
           % 权值更新
           Wt = W;  %当前时刻W
           for j = 1:s1
              DW(j) = eta*Error(i)*H(j);                
              W(j) = Wt(j) + DW(j) + alpha.*(Wt1(j)-Wt2(j));  %W update
           end
           Wt2 = Wt1;
           Wt1 = Wt;
        end
        % 检测是否达到误差要求
        e(cnt) = (norm(Error))^2/2/len;
        if e(cnt) < e_tol
            break;
        end
    end
    

    检验训练结果

    %% 检验训练结果
    idx_vad = (1:20:1000);
    u_test = u(idx_vad);
    for i = 1:length(idx_vad)
        x = u_test(i);
        for j = 1:s1
            H(j) = exp(-(x-c(j))^2/(2*b(j)^2));    %隐含层计算
        end
        y_test(i) = W*H;     %神经网络预测值
    end
    figure(1)
    plot(u,y,'b--','LineWidth',1);
    hold on
    plot(u_test,y_test,'r-*');
    legend('reference','estimation')
    grid on
    figure(2)
    plot(e(1:cnt));
    grid on
    legend('error')
    %% 检验2
    for i = 1:1000
        u_test2(i) = i*ts*5;
        y_test2(i) = sin(u_test2(i));
        x = u_test2(i);
       for j = 1:s1
            H(j) = exp(-(x-c(j))^2/(2*b(j)^2));    %隐含层计算
        end 
        y_vad2(i) = W*H;
    end
    figure(3)
    plot(u_test2,y_vad2,'r','LineWidth',0.75);
    hold on
    plot(u_test2,y_test2,'b--','LineWidth',1)
    grid on
    legend('estimation','reference')
    
    展开全文
  • 重点讲述了EEMD的故障特征提取研究的方法和基本原理,简述径向基函数神经网络在故障诊断领域当中的应用。在故障模拟转子试验台上进行实验研究,采集足够的样本信号数据,利用集合经验模式分解原理来进行信号的特征提取,...
  • RBF神经网络参考模型自适应MATLAB实现(分析)

    万次阅读 多人点赞 2018-12-06 17:22:48
    由于BP神经网络的收敛速度慢,不适合安在自适应系统里,所以选择了速度比较快的RBF神经网络,看了关于RBF神经网络自适应控制的一些原理和MATLAB代码,有一些自己的理解写在这里。 一般的神经网络的作用是去做一些...
  • Python实战RBF神经网络

    千次阅读 2021-08-06 09:09:22
    之前我们讲了神经网络,人工神经网络是受到人类大脑结构的启发而创造出来的,这也是它能拥有真智能的根本原因。在我们的大脑中,有数十亿个称为神经元的细胞,它们连接成了一个神经网络。 人工神经网络正是模仿了...
  • RBF神经网络介绍

    2011-10-30 21:09:58
    介绍 rbf神经网络 是一本很好的ppt文档教材 专门介绍RBF发展过程 和算法
  • Matlab实现BP神经网络和RBF神经网络(二)

    万次阅读 多人点赞 2017-05-09 15:50:49
    在上一篇博文中:Matlab实现BP神经网络和RBF神经网络(一) 中,我们讨论了BP网络设计部分,下面我们将设计RBF网络并将它们结果与SVM对比。数据格式不变,详情请看上一篇博文。RBF神经网络:RBF网络和BP网络都是非...
  • 风机系统大多都是大滞后、强耦合、非线性的系统,针对传统的PID控制、开环恒压频比控制对风机这类负载达不到理想的控制...分析了综合节电控制器的原理、建立数学模型以及模糊RBF神经网络控制器的设计,并进行MATLAB仿真。
  • RBF神经网络与BP神经网络优缺点比较 1. RBF 的泛化能力在多个方面都优于BP 网络, 但是在解决具有相同精度要求的问题时, BP 网络的结构要比RBF 网络简单。 2. RBF 网络的逼近精度要明显高于BP 网络,它几乎能实现...
  • 傻瓜攻略(六)——MATLAB实现RBF神经网络

    千次阅读 多人点赞 2020-07-25 22:08:08
    1989年,Jackson论证了RBF神经网络对非线性连续函数的一致逼近性能。 RBF神经网络有很强的逼近能力、分类能力和学习速度。其工作原理是把网络看成对未知函数的逼近,任何函数都可以表示成一组基函数的加权和,也即...
  • matlab RBF 神经网络拟合

    千次阅读 2020-08-17 15:42:49
    该函数可以用来设计一个近似径向基网络(approximate RBF)。调用格式为: [net,tr]=newrb(P,T,GOAL,SPREAD,MN,DF) 其中P为Q组输入向量组成的R*Q位矩阵,T为Q组目标分类向量组成的S*Q维矩阵。GOAL为均方误差目标...
  • 深度学习 --- 径向基神经网络RBF详解

    万次阅读 多人点赞 2018-11-25 12:45:50
    上一节我们基本上打开了深度学习的大门,其实下一步应该是卷积神经网络即CNN了,但是呢卷积神经网络的最后一层采用的是径向基神经网络,为了以后到CNN不用再费力气将RBF和保持CNN的整体性和连贯性,因此这里我们系统...
  • RBF神经网络

    千次阅读 2019-09-25 10:05:08
    RBF神经网络 RBF神经网络通常只有三层,即输入层、中间层和输出层。其中中间层主要计算输入x和样本矢量c(记忆样本)之间的欧式距离的Radial Basis Function (RBF)的值,输出层对其做一个线性的组合。 径向基函数...
  • RBF神经网络与BP网络优缺点比较

    万次阅读 2018-07-24 08:37:31
    RBF神经网络与BP神经网络优缺点比较 1. RBF 的泛化能力在多个方面都优于BP 网络, 但是在解决具有相同精度要求的问题时, BP 网络的结构要比RBF 网络简单。 2. RBF 网络的逼近精度要明显高于BP 网络,它几乎能实现...
  • RBF神经网络是一种3层的前向网络,其基本工作原理是:利用RBF构成的隐藏层空间对低维的输入矢量进行投影,将数据变换到高维空间中去,以使原来线性不可分的问题能够变得线性可分。下图为径向基神经网络的基本结构...
  • 深度学习之 RBF神经网络

    千次阅读 2020-05-11 13:57:27
    RBF神经网络通常只有三层,即输入层、中间层和输出层。其中中间层主要计算输入x和样本矢量c(记忆样本)之间的欧式距离的Radial Basis Function (RBF)的值,输出层对其做一个线性的组合。 径向基函数: RBF神经...
  • RBF具体原理网络上很多文章一定讲得比我好,所以我也不费口舌了,这里只说一说对RBF网络的一些直观的认识 1 RBF是一种两层的网络 是的,RBF结构上并不复杂,只有两层:隐层和输出层。其模型可以数学表示为:\ y ...
  • RBF神经网络与BP神经网络优缺点比较

    万次阅读 多人点赞 2017-08-02 21:02:02
    RBF神经网络与BP神经网络优缺点比较 (2016-05-31 21:37:04) 转载▼ 标签: 神经网络 RBF神经网络与BP神经网络优缺点比较 1. RBF 的泛化能力在多个方面都优于BP 网络, 但是在解决具有相同精度要求的问题时, BP ...
  • 详细地说明了RBF神经网络的各种算法实现,方便大家学习神经网络的原理,进一步加深了对神经网络的认识。
  • RBF神经网络以及Python实现

    万次阅读 2019-06-24 13:35:02
    RBF网络能够逼近任意非线性的函数。可以处理系统内难以解析的规律性,具有很好的泛化能力,并且具有较快的学 习速度。当网络的一个或多个可调参数(权值或阈值)对任何一个输出都有影响时,这样的网络称为全局逼近...
  • 采用Matlab/Simulink的TrueTime工具箱建立了无线网络时延控制系统仿真模型,介绍了模型中网络模块、执行器模块、控制器模块的设计及RBF神经网络整定PID控制器参数的实现原理。仿真结果表明,与常规PID控制策略相比,RBF...
  • 使用RBF神经网络完成函数拟合

    千次阅读 2021-10-24 15:53:40
    RBF网络的结构与多层前向网络类似,它是一种三层前向网络。 输入层由信号源结点组成;第二层为隐含层,隐单元数视所描述问题的需要而定,隐单元的变换函数是RBF径向基函数,它是对中心点径向对称且衰减的非负非线性...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,436
精华内容 1,374
关键字:

rbf神经网络原理