精华内容
下载资源
问答
  • 径向基函数网络

    2018-07-01 19:38:00
    介绍 ...RBF的隐含层是非线性的,采用径向基函数作为基函数,从而将输入向量空间转换到隐含层空间,使原来的线性不可分问题变为线性可分,输出层则是线性的。 径向基神经网络可以分为正则化网络...

    介绍

    径向基函数网络(Radial Basis Function,RBF)是由三层构成的前向网络:第一层为输入层,节点数等于输入的维数;第二层为隐含层,节点个数视问题复杂度而定;第三层为输出层,节点数等于输出数据的维度。RBF的隐含层是非线性的,采用径向基函数作为基函数,从而将输入向量空间转换到隐含层空间,使原来的线性不可分问题变为线性可分,输出层则是线性的。

    径向基神经网络可以分为正则化网络广义网络,在实践中被广泛应用的是广义网络。

    正则化网络的隐层节点数等于训练样本数,因此如果训练样本个数N过大,网络的计算量将是惊人的。广义网络隐层选择I个节点,(I<N)

     径向基函数

    radial basis function (RBF) is a real-valued function whose value depends only on the distance from the origin, so that{\textstyle \phi \left(\mathbf {x} \right)=\phi \left(\left\|\mathbf {x} \right\|\right)}; or alternatively on the distance from some other point {\textstyle \mathbf {c} }, called a center, so that {\textstyle \phi \left(\mathbf {x} ,\mathbf {c} \right)=\phi \left(\left\|\mathbf {x} -\mathbf {c} \right\|\right)}.

    Any function {\textstyle \phi} that satisfies the property {\textstyle \phi \left(\mathbf {x} \right)=\phi \left(\left\|\mathbf {x} \right\|\right)} is a radial function. The norm is usually Euclidean distance, although other distance functions are also possible.

     由径向基函数的定义可知,函数值仅与自变量的范数有关。范数是对函数、向量和矩阵定义的一种度量形式,只要一种度量形式同时满足以下三个条件,即可成为一种范数:

    一个长为n的向量X的p-范数定义为:

     概率神经网络

    概率神经网络(Probabilistic Neutral Networks,PNN)可以视为一种径向基神经网络,杂RBF网络的基础上,融合了密度函数估计和贝叶斯决策理论。

    转载于:https://www.cnblogs.com/larry-xia/p/9251044.html

    展开全文
  • 径向基函数神经网络进行异或分类,首先在4个象限随机生训练数据,然后进行FCM聚类,取4个隐层神经元代表分成4类,最后通过伪逆求出输出层神经元权重,输出通过0和1区分
  • 选取太阳辐照时间、辐照强度以及气温等影响光伏阵列输出功率的主要气象因素,根据相似日的输出功率具有较强的关联度,提出选择相似日的方法,设计基于相似日和径向基函数(RBF)神经网络的光伏阵列输出功率预测模型...
  • 径向基函数网络由两层组成:第一层为隐含的径向基层,第二层为输出线性层 问题描述—设计一个径向基函数网络用于完成函数逼近的任务 已知一个函数,涉及一个径向基函数神经网络来对它进行逼近
  • 径向基函数神经网络是不同于BP神经网络的另一种的前馈神经网络,由输入层、一层非线性隐层(径向基层)和线性输出层组成的。 关于径向基函数神经网络,首先要介绍一个定理,cover定理,对于一个复杂的在低维空间...

    径向基函数神经网络是不同于BP神经网络的另一种的前馈神经网络,由输入层、一层非线性隐层(径向基层)和线性输出层组成的。

    关于径向基函数神经网络,首先要介绍一个定理,cover定理,对于一个复杂的在低维空间表现为非线性可分的模型分类问题,当我们从该低维空间由某种非线性变换而得到的高维空间来看待时,原来的问题就可能转化为一个简单的线性可分的模式分类问题。再看回径向基函数神经网络的结构,它只有一层隐层,而且隐层的神经元数量是多于输入层的,所以就可以看成经过隐层的处理后,原来的输入特征由n维变成了更高的n+k维。这就是径向基函数神经网络的核心思想。

    接下来我们首先从BP神经网络和径向基函数神经网络的区别入手,分析径向基神经网络的一些优点。

    首先,BP神经网络的隐节点(隐层神经元)采用输入变量与权向量的内积作为激活函数的自变量,激活函数采用sigmoid函数,我们知道,在训练过程中,BP算法会根据样本数据不断反向调整参数(权向量),使得最后得到的模型能够尽可能拟合所有数据(或者说模型损失函数尽可能小),也就是说,所有数据对于模型参数的调整都有同等重要的地位,这种现象就称为全局逼近。

    而RBF神经网络则是采用输入变量与基函数中心的距离(如欧氏距离)作为激活函数的自变量,同时激活函数采用径向基函数,采用输入变量与中心的距离作为激活函数的自变量和核回归的思想是相似的,也就是说,远离各个中心的数据,对于模型参数调整的影响是较小的,真正起主要作用的是靠近中心变量的样本数据,所以这就属于局部逼近。

    针对BP神经网络和RBF神经网络的区别,就可以推导出,RBF神经网络比起BP神经网络的优点主要在于计算速度,因为RBF只有一层隐层,BP可能有多层隐层,同时BP是全局逼近而RBF是局部逼近,这些都会影响计算速度。

    明确了RBF神经网络的优点后,再来具体介绍RBF神经网络的过程。BP神经网络要求解的只有权向量,而RBF神经网络需要求解的参数有基函数的中心、方差以及隐层到输出层的权值。首先关于中心,其实和样条回归的节点、loess的拟合点是一个东西,通过一组中心将原来的样本数据集划分到不同区间,再局部进行拟合,所以中心变量的数量和位置对于最后拟合得到的函数的精度和形状影响很大。所以REF神经网络可以分为两个过程,第一个是确定基函数的中心和方差,然后才是确定权值。

    关于基函数的中心选取方法有很多,第一种是直接计算法,其实就是随机选取中心;第二种是自组织学习选取中心,主要采用K-均值聚类法来选择中心;第三种是通过梯度下降法这类有监督学习方法来选取中心,除此之外还有很多不同的方法,但目前为止也没有通用的较好的策略去决定中心,或多或少会存在计算量大、收敛速度较慢等问题,所以目前针对这些问题,也有提出了一种更复杂的基于合作性协同进化的RBF学习算法,去分析出最优的隐层神经元数量以及基函数中心、方差。

    确定了基函数的中心和方差之后,我们就能进一步得到模型的输出表达式(以高斯函数作为径向基函数为例):

    R(xpxi)=exp(12δ2xpxi2)R(x_p - x_i) = exp(\frac{1}{-2\delta ^2} ||x_p - x_i ||^2)

    yi=i=1hωijexp(12δ2xpxi2)y_i = \sum_{i=1}^h \omega_{ij} exp(\frac{1}{-2\delta ^2} ||x_p - x_i ||^2)

    最后,根据实际的情况(回归还是分类问题),选择适当的损失函数,按照常规的方法去求解最优权值。

    总的来说,RBF神经网络可以看成是一种基于局部逼近思想而改进的神经网络,理论上和BP神经网络相比计算效率更高,可是另一方面,我认为BP神经网络的各个步骤是十分明确的,可以一步步推导的,而RBF神经网络在确定径向基函数相关参数时,根据不同的样本数据分布或许会有更好的计算方法,很难确定一种通用的最优的求解方法,这种不确定性就变成了RBF神经网络的一大局限。

    想浏览更多关于数学、机器学习、深度学习的内容,可浏览本人博客

    展开全文
  • 径向基函数网络是一种单隐层前馈神经网络,它使用径向基函数作为隐层神经元激活函数,而输出层则是对隐层神经元输出的线性组合,假定输入为d维向量x,输出为实值,则RBF网络可表示为 其中q为隐层神经元个数,Ci...

    径向基函数网络是一种单隐层前馈神经网络,它使用径向基函数作为隐层神经元激活函数,而输出层则是对隐层神经元输出的线性组合,假定输入为d维向量x,输出为实值,则RBF网络可表示为

     

     

    其中q为隐层神经元个数,Ci和ωi分别是第i个隐层神经元所对应的中心和权重,ρ(x,Ci)是径向基函数,这是某种沿径向对称的标量函数,通常定义为样本x到数据中心Ci之间的欧氏距离的单调函数。常用的高斯径向基函数形如

     

     

    具有足够多隐层神经元的RBF网络能以任意精度逼近任意连续函数。

    通常采用两步过程来训练RBF网络:

    1、确定神经元中心Ci,常用的方式包括随机采样、聚类等。

    2、利用BP算法等来确定参数ωi和β

    转载于:https://www.cnblogs.com/walkshadow/p/8428981.html

    展开全文
  • RBF(径向基函数)神经网络

    万次阅读 多人点赞 2017-07-06 11:01:32
    径向基函数(RBF)神经网络 自己的总结: 1、输入层到隐藏层之间不是通过权值和阈值进行连接的,而是通过输入样本与隐藏层点之间的距离(与中心点的距离)连接的。 2、得到距离之后,将距离代入径向...

    径向基函数(RBF)神经网络



    自己的总结:

    1、输入层到隐藏层之间不是通过权值和阈值进行连接的,而是通过输入样本与隐藏层点之间的距离(与中心点的距离)连接的。

    2、得到距离之后,将距离代入径向基函数,得到一个数值。数值再与后边的权值相乘再求总和,就得到了相应输入的输出。

    3、在训练网络之前,需要确定中心点的个数,和中心点的位置。以及求出隐藏层各径向基函数的方差(宽窄程度)。和隐藏层和输出层之间的权值。

    4、中心点个数、中心点位置、方差、权值都可以通过下文所述的方法求出来。

    5、径向基函数也是一种基,可以通过对其线性组合,来对非线性函数进行拟合。

    6、RBF神经网络只需要了解其中的原理。然后给了训练数据,求出上述几个参数,再输入测试数据,就可以预测输出了。


    如第三个图,径向基函数的




    RBF网络能够逼近任意的非线性函数,可以处理系统内的难以解析的规律性,具有良好的泛化能力,并有很快的学习收敛速度,已成功应用于非线性函数逼近、时间序列分析、数据分类、模式识别、信息处理、图像处理、系统建模、控制和故障诊断等。

    简单说明一下为什么RBF网络学习收敛得比较快。当网络的一个或多个可调参数(权值或阈值)对任何一个输出都有影响时,这样的网络称为全局逼近网络。由于对于每次输入,网络上的每一个权值都要调整,从而导致全局逼近网络的学习速度很慢。BP网络就是一个典型的例子。

    如果对于输入空间的某个局部区域只有少数几个连接权值影响输出,则该网络称为局部逼近网络。常见的局部逼近网络有RBF网络、小脑模型(CMAC)网络、B样条网络等。

    径向基函数解决插值问题

    完全内插法要求插值函数经过每个样本点,即。样本点总共有P个。

    RBF的方法是要选择P个基函数,每个基函数对应一个训练数据,各基函数形式为,由于距离是径向同性的,因此称为径向基函数。||X-Xp||表示差向量的模,或者叫2范数。

    基于为径向基函数的插值函数为:

    输入X是个m维的向量,样本容量为P,P>m。可以看到输入数据点Xp是径向基函数φp的中心。

    隐藏层的作用是把向量从低维m映射到高维P,低维线性不可分的情况到高维就线性可分了。

    将插值条件代入:

    写成向量的形式为,显然Φ是个规模这P对称矩阵,且与X的维度无关,当Φ可逆时,有

    对于一大类函数,当输入的X各不相同时,Φ就是可逆的。下面的几个函数就属于这“一大类”函数:

    1)Gauss(高斯)函数

    2)Reflected Sigmoidal(反常S型)函数

    3)Inverse multiquadrics(拟多二次)函数

    σ称为径向基函数的扩展常数,它反应了函数图像的宽度,σ越小,宽度越窄,函数越具有选择性。

    完全内插存在一些问题:

    1)插值曲面必须经过所有样本点,当样本中包含噪声时,神经网络将拟合出一个错误的曲面,从而使泛化能力下降。

    由于输入样本中包含噪声,所以我们可以设计隐藏层大小为K,K<P,从样本中选取K个(假设不包含噪声)作为Φ函数的中心。

    2)基函数个数等于训练样本数目,当训练样本数远远大于物理过程中固有的自由度时,问题就称为超定的,插值矩阵求逆时可能导致不稳定。

    拟合函数F的重建问题满足以下3个条件时,称问题为适定的:

    1. 解的存在性
    2. 解的唯一性
    3. 解的连续性

    不适定问题大量存在,为解决这个问题,就引入了正则化理论。

    正则化理论

    正则化的基本思想是通过加入一个含有解的先验知识的约束来控制映射函数的光滑性,这样相似的输入就对应着相似的输出。

    寻找逼近函数F(x)通过最小化下面的目标函数来实现:

    加式的第一项好理解,这是均方误差,寻找最优的逼近函数,自然要使均方误差最小。第二项是用来控制逼近函数光滑程度的,称为正则化项,λ是正则化参数,D是一个线性微分算子,代表了对F(x)的先验知识。曲率过大(光滑度过低)的F(x)通常具有较大的||DF||值,因此将受到较大的惩罚。

    直接给出(1)式的解:

    权向量********************************(2)

    G(X,Xp)称为Green函数,G称为Green矩阵。Green函数与算子D的形式有关,当D具有旋转不变性和平移不变性时,。这类Green函数的一个重要例子是多元Gauss函数:

    正则化RBF网络

    输入样本有P个时,隐藏层神经元数目为P,且第p个神经元采用的变换函数为G(X,Xp),它们相同的扩展常数σ。输出层神经元直接把净输入作为输出。输入层到隐藏层的权值全设为1,隐藏层到输出层的权值是需要训练得到的:逐一输入所有的样本,计算隐藏层上所有的Green函数,根据(2)式计算权值。

    广义RBF网络

    Cover定理指出:将复杂的模式分类问题非线性地映射到高维空间将比投影到低维空间更可能线性可分。

    广义RBF网络:从输入层到隐藏层相当于是把低维空间的数据映射到高维空间,输入层细胞个数为样本的维度,所以隐藏层细胞个数一定要比输入层细胞个数多。从隐藏层到输出层是对高维空间的数据进行线性分类的过程,可以采用单层感知器常用的那些学习规则,参见神经网络基础和感知器

    注意广义RBF网络只要求隐藏层神经元个数大于输入层神经元个数,并没有要求等于输入样本个数,实际上它比样本数目要少得多。因为在标准RBF网络中,当样本数目很大时,就需要很多基函数,权值矩阵就会很大,计算复杂且容易产生病态问题。另外广RBF网与传统RBF网相比,还有以下不同:

    1. 径向基函数的中心不再限制在输入数据点上,而由训练算法确定。
    2. 各径向基函数的扩展常数不再统一,而由训练算法确定。
    3. 输出函数的线性变换中包含阈值参数,用于补偿基函数在样本集上的平均值与目标值之间的差别。

    因此广义RBF网络的设计包括:

    结构设计--隐藏层含有几个节点合适

    参数设计--各基函数的数据中心及扩展常数、输出节点的权值。

     

    下面给出计算数据中心的两种方法:

    1. 数据中心从样本中选取。样本密集的地方多采集一些。各基函数采用统一的偏扩展常数:


      dmax是所选数据中心之间的最大距离,M是数据中心的个数。扩展常数这么计算是为了避免径向基函数太尖或太平。
    2. 自组织选择法,比如对样本进行聚类、梯度训练法、资源分配网络等。各聚类中心确定以后,根据各中心之间的距离确定对应径向基函数的扩展常数。



      λ是重叠系数。

    接下来求权值W时就不能再用了,因为对于广义RBF网络,其行数大于列数,此时可以求Φ伪逆。

     数据中心的监督学习算法

    最一般的情况,RBF函数中心、扩展常数、输出权值都应该采用监督学习算法进行训练,经历一个误差修正学习的过程,与BP网络的学习原理一样。同样采用梯度下降法,定义目标函数为

    ei为输入第i个样本时的误差信号。

    上式的输出函数中忽略了阈值。

    为使目标函数最小化,各参数的修正量应与其负梯度成正比,即

    具体计算式为

    上述目标函数是所有训练样本引起的误差总和,导出的参数修正公式是一种批处理式调整,即所有样本输入一轮后调整一次。目标函数也可以为瞬时值形式,即当前输入引起的误差

    此时参数的修正值为:


    下面我们就分别用本文最后提到的聚类的方法和数据中心的监督学习方法做一道练习题。

    考虑Hermit多项式的逼近问题

    训练样本这样产生:样本数P=100,xi且服从[-4,4]上的均匀分布,样本输出为F(xi)+ei,ei为添加的噪声,服从均值为0,标准差为0.1的正态分布。

    (1)用聚类方法求数据中心和扩展常数,输出权值和阈值用伪逆法求解。隐藏节点数M=10,隐藏节点重叠系数λ=1,初始聚类中心取前10个训练样本。

    #include<iostream>
    #include<algorithm>
    #include<limits>
    #include<cassert>
    #include<cmath>
    #include<ctime>
    #include<cstdlib>
    #include<vector>
    #include<iomanip>
    #include"matrix.h"
     
    using namespace std;
     
    const int P=100;        //输入样本的数量
    vector<double> X(P);  //输入样本
    Matrix<double> Y(P,1);        //输入样本对应的期望输出
    const int M=10;         //隐藏层节点数目
    vector<double> center(M);       //M个Green函数的数据中心
    vector<double> delta(M);        //M个Green函数的扩展常数
    Matrix<double> Green(P,M);         //Green矩阵
    Matrix<double> Weight(M,1);       //权值矩阵
     
    /*Hermit多项式函数*/
    inline double Hermit(double x){
        return 1.1*(1-x+2*x*x)*exp(-1*x*x/2);
    }
     
    /*产生指定区间上均匀分布的随机数*/
    inline double uniform(double floor,double ceil){
        return floor+1.0*rand()/RAND_MAX*(ceil-floor);
    }
     
    /*产生区间[floor,ceil]上服从正态分布N[mu,sigma]的随机数*/
    inline double RandomNorm(double mu,double sigma,double floor,double ceil){
        double x,prob,y;
        do{
            x=uniform(floor,ceil);
            prob=1/sqrt(2*M_PI*sigma)*exp(-1*(x-mu)*(x-mu)/(2*sigma*sigma));
            y=1.0*rand()/RAND_MAX;
        }while(y>prob);
        return x;
    }
     
    /*产生输入样本*/
    void generateSample(){
        for(int i=0;i<P;++i){
            double in=uniform(-4,4);
            X[i]=in;
            Y.put(i,0,Hermit(in)+RandomNorm(0,0.1,-0.3,0.3));
        }
    }
     
    /*寻找样本离哪个中心最近*/
    int nearest(const vector<double>& center,double sample){
        int rect=-1;
        double dist=numeric_limits<double>::max();
        for(int i=0;i<center.size();++i){
            if(fabs(sample-center[i])<dist){
                dist=fabs(sample-center[i]);
                rect=i;
            }
        }
        return rect;
    }
     
    /*计算簇的质心*/
    double calCenter(const vector<double> &g){
        int len=g.size();
        double sum=0.0;
        for(int i=0;i<len;++i)
            sum+=g[i];
        return sum/len;
    }
     
    /*KMeans聚类法产生数据中心*/
    void KMeans(){
        assert(P%M==0);
        vector<vector<double> > group(M);          //记录各个聚类中包含哪些样本
        double gap=0.001;       //聚类中心的改变量小于为个值时,迭代终止
        for(int i=0;i<M;++i){   //从P个输入样本中随机选P个作为初始聚类中心
            center[i]=X[10*i+3];     //输入是均匀分布的,所以我们均匀地选取
        }
        while(1){
            for(int i=0;i<M;++i)
                group[i].clear();   //先清空聚类信息
            for(int i=0;i<P;++i){       //把所有输入样本归到对应的簇
                int c=nearest(center,X[i]);
                group[c].push_back(X[i]);
            }
            vector<double> new_center(M);       //存储新的簇心
            for(int i=0;i<M;++i){
                vector<double> g=group[i];
                new_center[i]=calCenter(g);
            }
            bool flag=false;
            for(int i=0;i<M;++i){       //检查前后两次质心的改变量是否都小于gap
                if(fabs(new_center[i]-center[i])>gap){
                    flag=true;
                    break;
                }
            }
            center=new_center;
            if(!flag)
                break;
        }
    }
     
    /*生成Green矩阵*/
    void calGreen(){
        for(int i=0;i<P;++i){
            for(int j=0;j<M;++j){
                Green.put(i,j,exp(-1.0*(X[i]-center[j])*(X[i]-center[j])/(2*delta[j]*delta[j])));
            }
        }
    }
     
    /*求一个矩阵的伪逆*/
    Matrix<double> getGereralizedInverse(const Matrix<double> &matrix){
        return (matrix.getTranspose()*matrix).getInverse()*(matrix.getTranspose());
    }
     
    /*利用已训练好的神经网络,由输入得到输出*/
    double getOutput(double x){
        double y=0.0;
        for(int i=0;i<M;++i)
            y+=Weight.get(i,0)*exp(-1.0*(x-center[i])*(x-center[i])/(2*delta[i]*delta[i]));
        return y;
    }
     
    int main(int argc,char *argv[]){<br>   srand(time(0));
        generateSample();       //产生输入和对应的期望输出样本
        KMeans();           //对输入进行聚类,产生聚类中心
        sort(center.begin(),center.end());      //对聚类中心(一维数据)进行排序
         
        //根据聚类中心间的距离,计算各扩展常数
        delta[0]=center[1]-center[0];      
        delta[M-1]=center[M-1]-center[M-2];
        for(int i=1;i<M-1;++i){
            double d1=center[i]-center[i-1];
            double d2=center[i+1]-center[i];
            delta[i]=d1<d2?d1:d2;
        }
         
        calGreen();     //计算Green矩阵
        Weight=getGereralizedInverse(Green)*Y;      //计算权值矩阵
         
        //根据已训练好的神经网络作几组测试
        for(int x=-4;x<5;++x){
            cout<<x<<"\t";
            cout<<setprecision(8)<<setiosflags(ios::left)<<setw(15);
            cout<<getOutput(x)<<Hermit(x)<<endl;      //先输出我们预测的值,再输出真实值
        }
        return 0;
    }

    并且我将其中其中的C++代码改写成了M文件

    复制代码
    %%  
    % 根据以下链接中的思想,把C++代码改写成M文件  
    % http://www.cnblogs.com/zhangchaoyang/articles/2591663.html  
    clear;clc;  
    P=101;%训练样本共P个  
    X=[]; %训练输入  
    Y=[]; %训练输出  
    M=10; %数据中心的个数(或说隐藏层的个数)  
      
      
    centers=[];%存储数据中心(或说核函数的个数)  
    deltas=[]; %存储核函数的标准差  
    weights=[];%存放网络的权值(或说每个核的权值)  
    set = {};  %存放不同簇所包含的所有样例  
    gap=0.1;   %这是用k_means法进行聚类的时候的停止规则  
    %**************************************************************************  
    %构造训练样本X,Y  
    X=[-4:0.08:4];  
    for i=1:P  
        Y(i)=1.1*(1-X(i)+2*X(i)^2)*exp(-X(i)^2/2);  
    end  
    Y=Y+0.1*randn(1,P);  
    %%  
    %**************************************************************************  
    %对输入进行聚类,(获得核函数的中心)  
    for i=1:M   
        %因为我们的X是均匀分布,所以初始化也为均匀的  
        centers(i)= X( i*floor( P/10 ) );  
    end  
    done=0;  
    while(~done)  
        for i=1:M  
           set{i}=[];  
        end  
        %计算P中每个点所属的簇  
        for i=1:P  
            distance=100;%设置一个比较大的值  
            for j=1:M  
                curr=abs(X(i)-centers(j));  
                if curr<distance  
                    sets=j;  
                    distance=curr;  
                end  
            end  
            set{sets}=[set{sets},X(i)];%把新分类的样例添到相应的簇中  
        end  
        %重新计算每个簇的质心  
        for i=1:M  
            new_centers(i)=sum(set{i})/length(set{i});  
        end  
        %根据各簇中心的更新情况决定是否已完成循环  
        done=0;  
    %     abs(centers-new_centers)  
        for i=1:M  
            if abs(centers(i)-new_centers(i))>gap  
                done=0;  
                break;  
            else  
                done=1;  
            end  
        end  
        centers=new_centers;  
    end  
    %计算出每个高斯核函数的标准差(重叠系数=1for i=1:M  
        curr=abs( centers-centers(i) );  
        [curr_2,b]=min(curr);  
        curr(b)=100;  
        curr_2=min(curr);  
        deltas(i)=1*curr_2;  
    end  
    %**************************************************************************  
    %根据d=sum(K*W)  
    %首先构造K为P×M的  
    for i=1:P  
        for j=1:M  
            curr=abs(X(i)-centers(j));  
            K(i,j)=exp( -curr^2/(2*deltas(j)^2) );  
        end  
    end  
    %计算权值矩阵  
    weights=inv(K'*K)*K'*Y';  
    %**************************************************************************  
    %测试计算出函数的情况  
    x_test=[-4:0.1:4];  
    for i=1:length(x_test)  
        sum=0;  
        for j=1:M  
            curr=weights(j)*exp(-abs(x_test(i)-centers(j))^2/(2*deltas(j)^2));  
            sum=sum+curr;  
        end  
        y_test(i)=sum;  
    end  
    figure(1)  
    scatter(X,Y,'k+');  
    hold on;  
    plot(x_test,y_test,'r.-')  
    复制代码

     

    (2)用梯度下降法训练RBF网络,设η=0.001,M=10,初始权值为[-0.1,0.1]内的随机数,初始数据中心为[-4,4]内的随机数,初始扩展常数取[0.1,0.3]内的随机数,目标误差为0.9,最大训练次数为5000。

    #include<iostream>
    #include<cassert>
    #include<cmath>
    #include<ctime>
    #include<cstdlib>
    #include<vector>
    #include<iomanip>
     
    using namespace std;
     
    const int P=100;        //输入样本的数量
    vector<double> X(P);  //输入样本
    vector<double> Y(P);      //输入样本对应的期望输出
    const int M=10;         //隐藏层节点数目
    vector<double> center(M);       //M个Green函数的数据中心
    vector<double> delta(M);        //M个Green函数的扩展常数
    double Green[P][M];         //Green矩阵
    vector<double> Weight(M);       //权值矩阵
    const double eta=0.001;     //学习率
    const double ERR=0.9;       //目标误差
    const int ITERATION_CEIL=5000;      //最大训练次数
    vector<double> error(P);  //单个样本引起的误差
     
    /*Hermit多项式函数*/
    inline double Hermit(double x){
        return 1.1*(1-x+2*x*x)*exp(-1*x*x/2);
    }
     
    /*产生指定区间上均匀分布的随机数*/
    inline double uniform(double floor,double ceil){
        return floor+1.0*rand()/RAND_MAX*(ceil-floor);
    }
     
    /*产生区间[floor,ceil]上服从正态分布N[mu,sigma]的随机数*/
    inline double RandomNorm(double mu,double sigma,double floor,double ceil){
        double x,prob,y;
        do{
            x=uniform(floor,ceil);
            prob=1/sqrt(2*M_PI*sigma)*exp(-1*(x-mu)*(x-mu)/(2*sigma*sigma));
            y=1.0*rand()/RAND_MAX;
        }while(y>prob);
        return x;
    }
     
    /*产生输入样本*/
    void generateSample(){
        for(int i=0;i<P;++i){
            double in=uniform(-4,4);
            X[i]=in;
            Y[i]=Hermit(in)+RandomNorm(0,0.1,-0.3,0.3);
        }
    }
     
    /*给向量赋予[floor,ceil]上的随机值*/
    void initVector(vector<double> &vec,double floor,double ceil){
        for(int i=0;i<vec.size();++i)
            vec[i]=uniform(floor,ceil);
    }
     
    /*根据网络,由输入得到输出*/
    double getOutput(double x){
        double y=0.0;
        for(int i=0;i<M;++i)
            y+=Weight[i]*exp(-1.0*(x-center[i])*(x-center[i])/(2*delta[i]*delta[i]));
        return y;
    }
     
    /*计算单个样本引起的误差*/
    double calSingleError(int index){
        double output=getOutput(X[index]);
        return Y[index]-output;
    }
     
    /*计算所有训练样本引起的总误差*/
    double calTotalError(){
        double rect=0.0;
        for(int i=0;i<P;++i){
            error[i]=calSingleError(i);
            rect+=error[i]*error[i];
        }
        return rect/2;
    }
     
    /*更新网络参数*/
    void updateParam(){
        for(int j=0;j<M;++j){
            double delta_center=0.0,delta_delta=0.0,delta_weight=0.0;
            double sum1=0.0,sum2=0.0,sum3=0.0;
            for(int i=0;i<P;++i){
                sum1+=error[i]*exp(-1.0*(X[i]-center[j])*(X[i]-center[j])/(2*delta[j]*delta[j]))*(X[i]-center[j]);
                sum2+=error[i]*exp(-1.0*(X[i]-center[j])*(X[i]-center[j])/(2*delta[j]*delta[j]))*(X[i]-center[j])*(X[i]-center[j]);
                sum3+=error[i]*exp(-1.0*(X[i]-center[j])*(X[i]-center[j])/(2*delta[j]*delta[j]));
            }
            delta_center=eta*Weight[j]/(delta[j]*delta[j])*sum1;
            delta_delta=eta*Weight[j]/pow(delta[j],3)*sum2;
            delta_weight=eta*sum3;
            center[j]+=delta_center;
            delta[j]+=delta_delta;
            Weight[j]+=delta_weight;
        }
    }
     
    int main(int argc,char *argv[]){
        srand(time(0));
        /*初始化网络参数*/
        initVector(Weight,-0.1,0.1);
        initVector(center,-4.0,4.0);
        initVector(delta,0.1,0.3);
        /*产生输入样本*/
        generateSample();
        /*开始迭代*/
        int iteration=ITERATION_CEIL;
        while(iteration-->0){
            if(calTotalError()<ERR)      //误差已达到要求,可以退出迭代
                break;
            updateParam();      //更新网络参数
        }
        cout<<"迭代次数:"<<ITERATION_CEIL-iteration-1<<endl;
         
        //根据已训练好的神经网络作几组测试
        for(int x=-4;x<5;++x){
            cout<<x<<"\t";
            cout<<setprecision(8)<<setiosflags(ios::left)<<setw(15);
            cout<<getOutput(x)<<Hermit(x)<<endl;      //先输出我们预测的值,再输出真实值
        }
        return 0;
    }

     

    径向基网络(RBF network)之BP监督训练

    zouxy09@qq.com

    http://blog.csdn.net/zouxy09

     

           之前看了流行学习的时候,感觉它很神奇,可以将一个4096维的人脸图像降到3维。然后又看到了可以用径向基网络来将这3维的图像重构到4096维。看到效果的时候,我和小伙伴们都惊呆了(呵呵,原谅我的孤陋寡闻)。见下图,第1和3行是原图像,维度是64x64=4096维,第2和第4行是将4096维的原图像用流行学习算法降到3维后,再用RBF网络重构回来的图像(代码是参考一篇论文写的)。虽然在重构领域,这效果不一定是好的,但对于无知的我,其中的奥妙勾引了我,使我忍不住又去瞻仰了一番。

     

           推荐大家先看看这个博主的这篇博文:

    http://www.cnblogs.com/zhangchaoyang/articles/2591663.html

     

    一、径向基函数

           在说径向基网络之前,先聊下径向基函数(Radical Basis Function,RBF)。径向基函数(Radical Basis Function,RBF)方法是Powell在1985年提出的。所谓径向基函数,其实就是某种沿径向对称的标量函数。通常定义为空间中任一点x到某一中心c之间欧氏距离的单调函数,可记作k(||x-c||),其作用往往是局部的,即当x远离c时函数取值很小。例如高斯径向基函数:

           当年径向基函数的诞生主要是为了解决多变量插值的问题。可以看下面的图。具体的话是先在每个样本上面放一个基函数,图中每个蓝色的点是一个样本,然后中间那个图中绿色虚线对应的,就表示的是每个训练样本对应一个高斯函数(高斯函数中心就是样本点)。然后假设真实的拟合这些训练数据的曲线是蓝色的那根(最右边的图),如果我们有一个新的数据x1,我们想知道它对应的f(x1)是多少,也就是a点的纵坐标是多少。那么由图可以看到,a点的纵坐标等于b点的纵坐标加上c点的纵坐标。而b的纵坐标是第一个样本点的高斯函数的值乘以一个大点权值得到的,c的纵坐标是第二个样本点的高斯函数的值乘以另一个小点的权值得到。而其他样本点的权值全是0,因为我们要插值的点x1在第一和第二个样本点之间,远离其他的样本点,那么插值影响最大的就是离得近的点,离的远的就没什么贡献了。所以x1点的函数值由附近的b和c两个点就可以确定了。拓展到任意的新的x,这些红色的高斯函数乘以一个权值后再在对应的x地方加起来,就可以完美的拟合真实的函数曲线了。

     

    二、径向基网络

           到了1988年, Moody和 Darken提出了一种神经网络结构,即RBF神经网络,属于前向神经网络类型,它能够以任意精度逼近任意连续函数,特别适合于解决分类问题。

           RBF网络的结构与多层前向网络类似,它是一种三层前向网络。输入层由信号源结点组成;第二层为隐含层,隐单元数视所描述问题的需要而定,隐单元的变换函数是RBF径向基函数,它是对中心点径向对称且衰减的非负非线性函数;第三层为输出层,它对输入模式的作用作出响应。从输人空间到隐含层空间的变换是非线性的,而从隐含层空间到输出层空间变换是线性的。

           RBF网络的基本思想是:用RBF作为隐单元的“基”构成隐含层空间,这样就可将输入矢量直接(即不需要通过权连接)映射到隐空间。根据Cover定理,低维空间不可分的数据到了高维空间会更有可能变得可分。换句话来说,RBF网络的隐层的功能就是将低维空间的输入通过非线性函数映射到一个高维空间。然后再在这个高维空间进行曲线的拟合。它等价于在一个隐含的高维空间寻找一个能最佳拟合训练数据的表面。这点与普通的多层感知机MLP是不同的。

           当RBF的中心点确定以后,这种映射关系也就确定了。而隐含层空间到输出空间的映射是线性的,即网络的输出是隐单元输出的线性加权和,此处的权即为网络可调参数。由此可见,从总体上看,网络由输人到输出的映射是非线性的,而网络输出对可调参数而言却又是线性的。这样网络的权就可由线性方程组直接解出,从而大大加快学习速度并避免局部极小问题。

           从另一个方面也可以这样理解,多层感知器(包括BP神经网络)的隐节点基函数采用线性函数,激活函数则采用Sigmoid函数或硬极限函数。而RBF网络的隐节点的基函数采用距离函数(如欧氏距离),并使用径向基函数(如Gaussian函数)作为激活函数。径向基函数关于n维空间的一个中心点具有径向对称性,而且神经元的输入离该中心点越远,神经元的激活程度就越低。隐节点的这一特性常被称为“局部特性”。

     

    三、RBF网络的设计与求解

           RBF的设计主要包括两个方面,一个是结构设计,也就是说隐藏层含有几个节点合适。另一个就是参数设计,也就是对网络各参数进行求解。由上面的输入到输出的网络映射函数公式可以看到,网络的参数主要包括三种:径向基函数的中心、方差和隐含层到输出层的权值。到目前为止,出现了很多求解这三种参数的方法,主要可以分为以下两大类:

    1、方法一:

           通过非监督方法得到径向基函数的中心和方差,通过监督方法(最小均方误差)得到隐含层到输出层的权值。具体如下:

    (1)在训练样本集中随机选择h个样本作为h个径向基函数的中心。更好的方法是通过聚类,例如K-means聚类得到h个聚类中心,将这些聚类中心当成径向基函数的h个中心。

    (2)RBF神经网络的基函数为高斯函数时,方差可由下式求解:

           式中cmax 为所选取中心之间的最大距离,h是隐层节点的个数。扩展常数这么计算是为了避免径向基函数太尖或太平。

    (3)隐含层至输出层之间神经元的连接权值可以用最小均方误差LMS直接计算得到,计算公式如下:(计算伪逆)(d是我们期待的输出值)

     

    2、方法二:

             采用监督学习算法对网络所有的参数(径向基函数的中心、方差和隐含层到输出层的权值)进行训练。主要是对代价函数(均方误差)进行梯度下降,然后修正每个参数。具体如下:

    (1)随机初始化径向基函数的中心、方差和隐含层到输出层的权值。当然了,也可以选用方法一中的(1)来初始化径向基函数的中心。

    (2)通过梯度下降来对网络中的三种参数都进行监督训练优化。代价函数是网络输出和期望输出的均方误差:

    然后每次迭代,在误差梯度的负方向已一定的学习率调整参数。

     

    四、代码实现:

    1、第一种方法

           第一种方法在zhangchaoyang的博客上面有C++的实现,只是上面针对的是标量的数据(输入和输出都是一维的)。而在Matlab中也提供了第一种方法的改进版(呵呵,个人觉得,大家可以在Matlab中运行open newrb查看下源代码)。

           Matlab提供的一个函数是newrb()。它有个技能就是可以自动增加网络的隐层神经元数目直到均方差满足我们要求的精度或者神经元数数目达到最大(也就是我们提供的样本数目,当神经元数目和我们的样本数目一致时,rbf网络此时的均方误差为0)为止。它使用方法也能简单:

    rbf = newrb(train_x, train_y);

    output = rbf(test_x);

          直接把训练样本给它就可以得到一个rbf网络了。然后我们把输入给它就可以得到网络的输出了。

     

    2、第二种方法

           第二种方法在zhangchaoyang的博客上面也有C++的实现,只是上面针对的还是标量的数据(输入和输出都是一维的)。但我是做图像的,网络需要接受高维的输入,而且在Matlab中,向量的运算要比for训练的运算要快很多。所以我就自己写了个可以接受向量输入和向量输出的通过BP算法监督训练的版本。BP算法可以参考这里:BackpropagationAlgorithm ,主要是计算每层每个节点的残差就可以了。另外,我的代码是可以通过梯度检查的,但在某些训练集上面,代价函数值却会随着迭代次数上升,这就很奇怪了,然后降低了学习率还是一样。但在某些简单点的训练集上面还是可以工作的,虽然训练误差也挺大的(没有完全拟合训练样本)。所以大家如果发现代码里面有错误的部分,还望大家告知下。

           主要代码见下面:

    learnRBF.m

     

    1. %// This is a RBF network trained by BP algorithm    
    2. %// Author : zouxy    
    3. %// Date   : 2013-10-28    
    4. %// HomePage : http://blog.csdn.net/zouxy09    
    5. %// Email  : zouxy09@qq.com    
    6.   
    7. close all; clear; clc;  
    8.   
    9. %%% ************************************************  
    10. %%% ************ step 0: load data ****************  
    11. display('step 0: load data...');  
    12. % train_x = [1 2 3 4 5 6 7 8]; % each sample arranged as a column of train_x  
    13. % train_y = 2 * train_x;  
    14. train_x = rand(5, 10);  
    15. train_y = 2 * train_x;  
    16. test_x = train_x;  
    17. test_y = train_y;  
    18.   
    19. %% from matlab  
    20. % rbf = newrb(train_x, train_y);  
    21. % output = rbf(test_x);  
    22.   
    23.   
    24. %%% ************************************************  
    25. %%% ******** step 1: initialize parameters ********   
    26. display('step 1: initialize parameters...');  
    27. numSamples = size(train_x, 2);  
    28. rbf.inputSize = size(train_x, 1);  
    29. rbf.hiddenSize = numSamples;        % num of Radial Basis function  
    30. rbf.outputSize = size(train_y, 1);  
    31. rbf.alpha = 0.1;  % learning rate (should not be large!)  
    32.   
    33. %% centre of RBF  
    34. for i = 1 : rbf.hiddenSize  
    35.     % randomly pick up some samples to initialize centres of RBF  
    36.     index = randi([1, numSamples]);   
    37.     rbf.center(:, i) =  train_x(:, index);  
    38. end  
    39.   
    40. %% delta of RBF  
    41. rbf.delta = rand(1, rbf.hiddenSize);  
    42.   
    43. %% weight of RBF  
    44. r = 1.0; % random number between [-r, r]  
    45. rbf.weight = rand(rbf.outputSize, rbf.hiddenSize) * 2 * r - r;  
    46.   
    47.   
    48. %%% ************************************************  
    49. %%% ************ step 2: start training ************  
    50. display('step 2: start training...');  
    51. maxIter = 400;  
    52. preCost = 0;  
    53. for i = 1 : maxIter  
    54.     fprintf(1, 'Iteration %d ,', i);  
    55.     rbf = trainRBF(rbf, train_x, train_y);  
    56.     fprintf(1, 'the cost is %d \n', rbf.cost);  
    57.       
    58.     curCost = rbf.cost;  
    59.     if abs(curCost - preCost) < 1e-8  
    60.         disp('Reached iteration termination condition and Termination now!');  
    61.         break;  
    62.     end  
    63.     preCost = curCost;  
    64. end  
    65.   
    66.   
    67. %%% ************************************************  
    68. %%% ************ step 3: start testing ************   
    69. display('step 3: start testing...');  
    70. Green = zeros(rbf.hiddenSize, 1);  
    71. for i = 1 : size(test_x, 2)  
    72.     for j = 1 : rbf.hiddenSize  
    73.         Green(j, 1) = green(test_x(:, i), rbf.center(:, j), rbf.delta(j));  
    74.     end   
    75.     output(:, i) = rbf.weight * Green;  
    76. end  
    77. disp(test_y);  
    78. disp(output);  

     

    trainRBF.m

     

    1. function [rbf] = trainRBF(rbf, train_x, train_y)  
    2.     %%% step 1: calculate gradient  
    3.     numSamples = size(train_x, 2);  
    4.     Green = zeros(rbf.hiddenSize, 1);  
    5.     output = zeros(rbf.outputSize, 1);  
    6.     delta_weight = zeros(rbf.outputSize, rbf.hiddenSize);  
    7.     delta_center = zeros(rbf.inputSize, rbf.hiddenSize);  
    8.     delta_delta =  zeros(1, rbf.hiddenSize);  
    9.     rbf.cost = 0;  
    10.     for i = 1 : numSamples  
    11.         %% Feed forward  
    12.         for j = 1 : rbf.hiddenSize  
    13.             Green(j, 1) = green(train_x(:, i), rbf.center(:, j), rbf.delta(j));  
    14.         end   
    15.         output = rbf.weight * Green;      
    16.           
    17.         %% Back propagation  
    18.         delta3 = -(train_y(:, i) - output);  
    19.         rbf.cost = rbf.cost + sum(delta3.^2);  
    20.         delta_weight = delta_weight + delta3 * Green';  
    21.         delta2 = rbf.weight' * delta3 .* Green;  
    22.         for j = 1 : rbf.hiddenSize  
    23.             delta_center(:, j) = delta_center(:, j) + delta2(j) .* (train_x(:, i) - rbf.center(:, j)) ./ rbf.delta(j)^2;  
    24.             delta_delta(j) = delta_delta(j)+ delta2(j) * sum((train_x(:, i) - rbf.center(:, j)).^2) ./ rbf.delta(j)^3;  
    25.         end  
    26.     end  
    27.   
    28.     %%% step 2: update parameters  
    29.     rbf.cost = 0.5 * rbf.cost ./ numSamples;  
    30.     rbf.weight = rbf.weight - rbf.alpha .* delta_weight ./ numSamples;  
    31.     rbf.center = rbf.center - rbf.alpha .* delta_center ./ numSamples;  
    32.     rbf.delta = rbf.delta - rbf.alpha .* delta_delta ./ numSamples;  
    33. end  

     

    green.m

     

    1. function greenValue = green(x, c, delta)  
    2.     greenValue = exp(-1.0 * sum((x - c).^2) / (2 * delta^2));  
    3. end  

     

    五、代码测试

          首先,我测试了一维的输入,需要拟合的函数很简单,就是y=2x。

    train_x = [1 2 3 4 5 6 7 8];

    train_y = 2 * train_x;

         所以期待的输出就是:

    2    4     6     8   10    12    14   16

         我代码训练迭代200次后的网络输出是:

    2.0042   4.0239    5.9250    8.0214  10.0692   11.9351   14.0179  15.9958

          Matlab的newrb的输出是:

    2.0000   4.0000    6.0000    8.0000  10.0000   12.0000   14.0000  16.0000

          可以看到,Matlab的是完美拟合啊。我的那个还是均方误差还是挺大的。

          然后,我测试了高维的输入,训练样本是通过Matlab的rand(5, 10)来得到的,它生成的是5行10列[0 1]之间的随机数。也就是说我们的样本是10个,每个样本的维度是5维。我们测试的也是很简单的函数y=2x。结果如下:

     

     

          关于这个结果,我也不说什么了。期待大家发现代码里面错误的地方,然后告知下,非常感谢。

     

    RBF神经网络与BP神经网络的比较

    RBF神经网络与BP神经网络的比较

    RBF神经网络与BP神经网络都是非线性多层前向网络,它们都是通用逼近器。对于任一个BP神经网络,总存在一个RBF神经网络可以代替它,反之亦然。但是这两个网络也存在着很多不同点,这里从网络结构、训练算法、网络资源的利用及逼近性能等方面对RBF神经网络和BP神经网络进行比较研究。

     

    (1) 从网络结构上看。 BP神经网络实行权连接,而RBF神经网络输入层到隐层单元之间为直接连接,隐层到输出层实行权连接。BP神经网络隐层单元的转移函数一般选择非线性函数(如反正切函数),RBF神经网络隐层单元的转移函数是关于中心对称的RBF(如高斯函数)。BP神经网络是三层或三层以上的静态前馈神经网络,其隐层和隐层节点数不容易确定,没有普遍适用的规律可循,一旦网络的结构确定下来,在训练阶段网络结构将不再变化;RBF神经网络是三层静态前馈神经网络,隐层单元数也就是网络的结构可以根据研究的具体问题,在训练阶段自适应地调整,这样网络的适用性就更好了。

     

     

     

     

    (2) 从训练算法上看。 BP神经网络需要确定的参数是连接权值和阈值,主要的训练算法为BP算法和改进的BP算法。但BP算法存在许多不足之处,主要表现为易限于局部极小值,学习过程收敛速度慢,隐层和隐层节点数难以确定;更为重要的是,一个新的BP神经网络能否经过训练达到收敛还与训练样本的容量、选择的算法及事先确定的网络结构(输入节点、隐层节点、输出节点及输出节点的传递函数)、期望误差和训练步数有很大的关系。RBF神经网络的训练算法在前面已做了论述,目前,很多RBF神经网络的训练算法支持在线和离线训练,可以动态确定网络结构和隐层单元的数据中心和扩展常数,学习速度快,比BP算法表现出更好的性能。

     

     

     

     

    (3) 从网络资源的利用上看。 RBF神经网络原理、结构和学习算法的特殊性决定了其隐层单元的分配可以根据训练样本的容量、类别和分布来决定。如采用最近邻聚类方式训练网络,网络隐层单元的分配就仅与训练样本的分布及隐层单元的宽度有关,与执行的任务无关。在隐层单元分配的基础上,输入与输出之间的映射关系,通过调整隐层单元和输出单元之间的权值来实现,这样,不同的任务之间的影响就比较小,网络的资源就可以得到充分的利用。这一点和BP神经网络完全不同,BP神经网络权值和阈值的确定由每个任务(输出节点)均方差的总和直接决定,这样,训练的网络只能是不同任务的折中,对于某个任务来说,就无法达到最佳的效果。而RBF神经网络则可以使每个任务之间的影响降到较低的水平,从而每个任务都能达到较好的效果,这种并行的多任务系统会使RBF神经网络的应用越来越广泛。

     

     

     

     

    总之,RBF神经网络可以根据具体问题确定相应的网络拓扑结构,具有自学习、自组织、自适应功能,它对非线性连续函数具有一致逼近性,学习速度快,可以进行大范围的数据融合,可以并行高速地处理数据。RBF神经网络的优良特性使得其显示出比BP神经网络更强的生命力,正在越来越多的领域内替代BP神经网络。目前,RBF神经网络已经成功地用于非线性函数逼近、时间序列分析、数据分类、模式识别、信息处理、图像处理、系统建模、控制和故障诊断等。

    rbf原理 

    所谓径向基函数 (Radial Basis Function 简称 RBF), 就是某种沿径向对称的标量函数。 
    通常定义为空间中任一点x到某一中心xc之间欧氏距离的单调函数 , 可记作 k(||x-xc||), 
    其作用往往是局部的 , 即当x远离xc时函数取值很小。最常用的径向基函数是高斯核函数 ,
    形式为 k(||x-xc||)=exp{- ||x-xc||^2/(2*σ)^2) } 其中xc为核函数中心,σ为函数的宽度参数 , 
    控制了函数的径向作用范围。在RBF网络中,这两个参数往往是可调的。 

    可以从两个方面理解 RBF 网络的作用 : 
    (1)把网络看成对未知函数f(x)的逼近器。
       一般任何函数都可表示成一组基函数的加权和 ,这相当于用隐层单元的输出函数构成一组基函数来逼近f(x) 
    (2)在RBF网络中以输入层到隐层的基函数输出是一种非线性映射,而输出则是线性的。
       这样,RBF网络可以看成是首先将原始的非线性可分的特征空间变换到另一空间(通常是高维空间),
       通过合理选择这一变换使在新空间中原问题线性可分,然后用一个线性单元元来解决问题。 
    在典型的RBE网络中有三组可调参数:隐层基函数中心、方差,以及输出单元的权值。

    这些参数的选择有三种常见的方法:
     (1)根据经验选择函数中心。
       比如只要训练样本的分布能代表所给问题 ,可根据经验选定均匀分布的M个中心, 
       其间距为d,可选取高斯核函数的方为σ=d/sqrt(2*M)。
     (2)用聚类方法选择基函数。
        可以各聚类中心作为核函数中心,而以各类样本的方差的某一函数作为各个基函数的宽度参数。 
       用(1)或(2)的方法选定了隐层基函旗的参数后,因输出单元是线性单元,它的权值可以简单地用最小二乘法
       直接计算出来。
     (3)将三组可调参数都通过训练样本用误差纠正算法求得。
       做法与BP方法类似,分别计算误差e(k)对各组参数的偏导数,然后用迭代求取参数。 
       研究表明,用于模式识别问题的RBF网络在一定意义上等价于首先用非参数方法估计出概率密度,
       必然后用它进行分类

    展开全文
  • 进行训练, 实现了永磁同步电机直接转矩控制的径向基函数神经元网络输出矢量选择. 该控制器可以简化获得输出 电压矢量的过程, 并具有并行计算速度快、转矩响应迅速的性能. 仿真结果验证了该控制器的有效性.</p>
  • 四.径向基函数网络

    2019-10-02 08:04:32
    BP神经网络是一种全局逼近网络,学习速度慢,本次介绍一种结构简单,收敛速度快,能够逼近任意非线性函数的网络——径向基函数网络。(Radial Basis Function, RBF)是根据生物神经元有局部响应的原理而将基函数引入...
  • 径向基函数网络是一种单隐层前馈神经网络,它使用径向基函数作为隐层神经元激活函数,而输出层则是对隐层神经元输出的线性组合,假定输入为d维向量x,输出为实值,则RBF网络可表示为   其中q为隐层神经元个数,Ci...
  • 径向基函数(Radial Basis Function)神经网络是具有唯一最佳逼近(克服局部极小值问题)、训练简洁、学习收敛速度快等良好性能的前馈型神经网络,目前已证明RBFNN能够以任意精度逼近任意连续的非线性网络,被广泛...
  • 其中隐含层是非线性的,采用径向基函数作为基函数(最常用的是高斯函数),从而将输入向量空间转化到隐含空间,使原来线性不可分的问题变得线性可分,输出层则是线性的。RBF网络能够逼近任意的非线性函数,可...
  • 径向基函数神经网络首先介绍一下网络结构:1.输入层为向量,维度为m,样本个数为n,线性函数为传输函数。2.隐藏层与输入层全连接,层内无连接,隐藏层神经元个数与样本个数相等,也就是n,传输函数径向基函数。3....
  • 深度学习之径向基函数神经网络RBFNN

    万次阅读 多人点赞 2018-08-08 16:54:40
    径向基函数(Radial Basis Function)神经网络是具有唯一最佳逼近(克服局部极小值问题)、训练简洁、学习收敛速度快等良好性能的前馈型神经网络,目前已证明RBFNN能够以任意精度逼近任意连续的非线性网络,被广泛...
  • 径向基函数(RBF)网络结构,基于产值理论输入层,由m0个源节点组成,其中m0是输入向量x的维数。隐藏层,由和训练样本的大小N相同个数的计算单元组成,每个单元都从数学上用一个径向基函数描述:第j个输入数据点xj定义...
  • 径向基函数网络是一种实现方式,其结构类似于单一隐藏层的神经网络,原理是在隐藏层用径向基函数将数据映射到高维特征空间,然后再在输出层对其输出进行线性分类。 这招最经典的应用便是支持向量
  • 1.径向基函数网络是三层前向网络 2.隐含层是非线性的,采用径向基函数作为基函数 3.输出层是线性的 4.应用:对非线性网络具有一致逼近的性能 二、径向基函数 1.范数 范数是对函数、向量和矩阵定义的一种度量...
  • 为解决差错反向传输神经网络在透明可重构光网络光性能监测中精度不足的问题,提出一种基于优化的径向基函数人工神经网络的光性能监测方案。在该方案中,以信号眼图参数为网络输入,以光信噪比、色散和偏振模色散为...
  • 网络的输入为从测试点得到的输入向量,输出为对应的故障。为了验证网络的泛化性能,对每种训练情况在元件容差为5%均匀分布的情况下,对非故障元件做蒙特卡罗分析,得到验证样本。测试结果,诊断准确率为86.6%,从而...
  • 本文将稍微介绍径向基函数的基础知识,之后以鸢尾花数据集为例,介绍三种RBFNN的权值更新方法(激活函数使用高斯函数),即:直接计算法,自组织选取法,有监督学习(梯度下降法),确定RBFNN的三部分权重(高斯函数...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 141
精华内容 56
关键字:

径向基输出函数