精华内容
下载资源
问答
  • RBF径向函数简介

    千次阅读 2019-01-13 17:18:39
    1.1 径向是什么? wiki给出好几种定义。其中rrr代表是范数,xi\mathbf x_ixi​可以看做中心点,x\mathbf xx是每个训练样本。 1.2 径向基选几个来进行拟合函数? 一般是训练样本个数。 1.3 拟合误差怎么算...

    1 理论

    RBF网络就是使用一组径向基进行拟合。
    在这里插入图片描述
    在这里插入图片描述

    有了这个思想,我们可以看这个网络的细节部分。
    1.1 径向基是什么?
    wiki给出好几种定义。其中rr代表是范数,xi\mathbf x_i可以看做中心点,x\mathbf x是每个训练样本。
    在这里插入图片描述
    1.2 径向基选几个来进行拟合函数?
    一般是训练样本的个数。

    1.3 拟合误差怎么算?
    一般神经网络是,通过拟合误差来训练得到权值矩阵W。RBF是通过,在这里插入图片描述
    这里,dd就是图中的yy.
    如果矩阵不是方阵,求的就是伪逆。
    在这里插入图片描述
    也就是,RBF网络直接用解方程的方式来获得W,不是常规计算拟合误差来求W。

    2 实践

    照搬链接的,有几行代码用numpy更简单地实现。

    from scipy import *
    from scipy.linalg import norm, pinv
     
    from matplotlib import pyplot as plt
    import numpy as np 
    
    class RBF:
         
        def __init__(self, indim, numCenters, outdim):
            self.indim = indim
            self.outdim = outdim
            self.numCenters = numCenters
            self.centers = [random.uniform(-1, 1, indim) for i in range(numCenters)]
            self.beta = 8
            self.W = random.random((self.numCenters, self.outdim))
             
        def _basisfunc(self, c, d):
            assert len(d) == self.indim
            return exp(-self.beta * norm(c-d)**2)
         
        def _calcAct(self, X):
            # calculate activations of RBFs
            G = zeros((X.shape[0], self.numCenters), float)
            for ci, c in enumerate(self.centers):
                for xi, x in enumerate(X):
                    G[xi,ci] = self._basisfunc(c, x)
            return G
         
        def train(self, X, Y):
            """ X: matrix of dimensions n x indim 
                y: column vector of dimension n x 1 """
             
            # choose random center vectors from training set
            random.seed(10)
    #        rnd_idx = random.permutation(X.shape[0])[:self.numCenters]
    #        self.centers = [X[i,:] for i in rnd_idx]
            self.centers = X[random.choice(X.shape[0],self.numCenters)]
            
    #        print ("center", self.centers)
            # calculate activations of RBFs
            G = self._calcAct(X)
    #        print ('G \n',G)
             
            # calculate output weights (pseudoinverse)
            self.W = dot(pinv(G), Y)
            return self.centers, G 
             
        def test(self, X):
            """ X: matrix of dimensions n x indim """
             
            G = self._calcAct(X)
            Y = dot(G, self.W)
            return Y
     
          
    if __name__ == '__main__':
        # ----- 1D Example ------------------------------------------------
        n = 100
         
    #    x = mgrid[-1:1:complex(0,n)].reshape(n, 1)
        x = np.linspace(-1,1,n).reshape(n,1)
        # set y and add random noise
        y = sin(3*(x+0.5)**3 - 1)
        # y += random.normal(0, 0.1, y.shape)
         
        # rbf regression
        rbf = RBF(1, 10, 1)
        center, G = rbf.train(x, y)
        z = rbf.test(x)
           
        # plot original data
        plt.figure(figsize=(12, 8))
        plt.plot(x, y, 'k-')
         
        # plot learned model
        plt.plot(x, z, 'r-', linewidth=2)
    #     
        # plot rbfs
        plt.plot(rbf.centers, zeros(rbf.numCenters), 'gs')
         
        for c in rbf.centers:
            # RF prediction lines
            cx = arange(c-0.7, c+0.7, 0.01)
            cy = [rbf._basisfunc(array([cx_]), array([c])) for cx_ in cx]
            plt.plot(cx, cy, '-', color='gray', linewidth=0.2)
         
        plt.xlim(-1.2, 1.2)
        plt.show()
    

    也可以用在分类的情况。

    if __name__ == '__main__':
        # ----- 1D Example ------------------------------------------------
        n = 100
        def createData():
            iris = load_iris()
            df = pd.DataFrame(iris.data, columns = iris.feature_names)
            df['label'] = iris.target
            df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 
                          'label']
            return df.iloc[:,2],df.iloc[:,-1]
        
        x,y = createData()
        x = np.array(x).reshape(-1,1)
    
        from sklearn import preprocessing
        one_hot = preprocessing.OneHotEncoder(sparse = False)
        y = one_hot.fit_transform(np.array(y).reshape(-1,1))
    
        # rbf classification
        rbf = RBF(1, 10, 1)
        center, G = rbf.train(x, y)
        z = rbf.test(x)
           
        # plot original data
        plt.figure(figsize=(12, 8))
        y_l= np.argmax(y, axis = 1)
        plt.scatter(x, y_l )
        plt.show()
        
        plt.figure(figsize=(12, 8))
        # plot learned model
        plt.scatter(x, np.argmax(z,axis = 1))
    
        plt.show()
    

    在这里插入图片描述
    一维的RBF效果不是很好。


    reference:

    1. python 实现RBF
    2. rbf 介绍
    3. 径向基函数
    展开全文
  • 其实什么是径向分布函数(Radial distribution function)并不需要我去赘述,毕竟百度一搜一大堆。这里给出一个我第一接触RDF时看到定义,图和公式给也比较清楚,比较好理解:RDF定义再说明一点,代码所依靠...

    什么是RDF?

    其实什么是径向分布函数(Radial distribution function)并不需要我去赘述,毕竟百度一搜一大堆。这里给出一个我第一接触RDF时看到的定义,图和公式给的也比较清楚,比较好理解:RDF定义再说明一点,代码所依靠的公式都是来自于剑桥大学的《THE ART OF MOLECULAR DYNAMICS SIMULATION》

    思路

    首先,因为我需要读lammps的输出的dump文件,所以readxyzufile()所实现的是读入dump文件的功能。然后进入正题,说白了,计算RDF就是计算粒子与粒子之间的距离,并按照距离的远近进行统计。在这里说明一下,为了能够使代码可以计算包含两种粒子的体系,在一些细节方面会有些小的变动。wrap(dr)实现的周期边界条件规范(wraparound);calRDF()实现的是计算粒子与粒子之间的距离,统计每一层的包含的粒子数。
    变量名称说明:
    numatom:体系内的粒子总数。
    nbins:计算RDF时,球层的总数。
    nframe:计算的帧数。
    rangemax:计算RDF的范围时0-rangemax。
    type_A:粒子A在dump文件中的名称。A粒子为中心粒子。
    region:盒子的边长。

    代码实现

    #calculate RDF
    import numpy as np
    from numpy import sqrt
    def readxyzufile():
    
        line1 = f.readline()
        line2 = f.readline()
        line3 = f.readline()
        line4 = f.readline()
        natoms = int(line4)
        if natoms != numatom:
            raise ValueError('numatoms is wrong')
        line5 = f.readline()
        line6 = f.readline()
        line7 = f.readline()
        line8 = f.readline()
        line9 = f.readline()
    
        for d in range(natoms):
            line = f.readline()
            xyz = line.split()
            atomid = int(xyz[0])
            type[atomid-1] = int(xyz[1])
            xu[atomid-1] = float(xyz[2])
            yu[atomid-1] = float(xyz[3])
            zu[atomid-1] = float(xyz[4])
            #print(atomid,xu[atomid-1])
    def wrap(dr):
        if dr > 0.5*region:
            dr -= region
        elif dr < -0.5*region:
            dr += region
    def calRDF():
        global num_of_A,num_of_B
        for i in range(numatom-1):
            if type[i] == type_A:
                num_of_A += 1
                ix = xu[i]
                iy = yu[i]
                iz = zu[i]
                #print(i)
                for j in range(i+1,numatom):
                    if type[j] == type_B:
                        num_of_B +=1
                        jx = xu[j]
                        jy = yu[j]
                        jz = zu[j]
                        #print(j)
    
                        dx = jx-ix
                        dy = jy-iy
                        dz = jz-iz
    
                        dx = wrap(dx)
                        dy = wrap(dy)
                        dz = wrap(dz)
    
                        dij = sqrt(dx*dx+dy*dy+dz*dz)
                        print(i,j,dx,dy,dz,dij)
                        if dij < rangemax:
                            layer = int(dij/dr)
                            #print(layer)
                            count[layer] +=1
    
    
    
    density = 1
    numatom = 64800
    nbins = 50
    nframe = 1
    rangemax = 20.0
    type_A = 1#RDF of atoms A with atom B
    type_B = 2
    region = 40.16
    vol = pow(region,3)
    filename = 'unwrap_90_ij400_xyz_2000wan.lammpstrj'
    f = open(filename)
    dr = rangemax/nbins
    num_of_A = 0
    num_of_B = 0
    type = []
    xu = []
    yu = []
    zu = []
    count = []
    g = []
    for i in range(nbins):
        count.append(0)
        g.append(0)
    for i in range(numatom):
        type.append(0)
        xu.append(0)
        yu.append(0)
        zu.append(0)
    
    for i in range(nframe):
        readxyzufile()
        calRDF()
    num_of_A = num_of_A/nframe
    #density_A = num_of_A/vol
    num_of_B = num_of_B/(nframe*num_of_A)
    density_B = num_of_B/vol
    f.close()
    f = open('./rdf_result', 'w')
    for i in range(nbins):
        #volume = 4*np.pi*(3*i*i*dr*dr*dr+3*i*dr*dr*dr+dr*dr*dr)/3
        normFac = vol/(4*np.pi*num_of_A*num_of_B*pow((i-0.5)*dr,2)*dr*nframe)
        #normFac = vol/(2*np.pi*numatom*numatom*pow((i-0.5)*dr,2)*dr*nframe)
        #print(density_B)
        print(count[i])
        print(normFac)
        g[i] = count[i]*normFac
        print >>f, '%g %g' % (i*dr,g[i])
    f.close()
    
    

    最后

    第一次自己去实现物理量的计算,代码可能还有些问题和不规范的地方,可以指出来大家一起交流讨论。

    展开全文
  • 先讨论核函数是如何把数据映射到高维空间,然后引入径向基函数作核函数,并特别说明高斯径向基函数几何意义,以及它作为核函数时为什么能把数据映射到无限维空间。 2.提到了径向基函数,就继续讨论下径向基...

           径向基函数(RBF)在神经网络领域扮演着重要的角色,如RBF神经网络具有唯一最佳逼近的特性,径向基作为核函数在SVM中能将输入样本映射到高维特征空间,解决一些原本线性不可分的问题。

          本文主要讨论:

           1. 先讨论核函数是如何把数据映射到高维空间的,然后引入径向基函数作核函数,并特别说明高斯径向基函数的几何意义,以及它作为核函数时为什么能把数据映射到无限维空间。

           2.提到了径向基函数,就继续讨论下径向基函数神经网络为什么能用来逼近。

           再看这文章的时候,注意核函数是一回事,径向基函数是另一回事。核函数表示的是高维空间里由于向量内积而计算出来的一个函数表达式(后面将见到)。而径向基函数是一类函数,径向基函数是一个它的值(y)只依赖于变量(x)距原点距离的函数,即 \phi(\mathbf{x}) = \phi(\|\mathbf{x}\|);也可以是距其他某个中心点的距离,即 \phi(\mathbf{x}, \mathbf{c}) = \phi(\|\mathbf{x}-\mathbf{c}\|) 引用自wiki . 也就是说,可以选定径向基函数来当核函数,譬如SVM里一般都用高斯径向基作为核函数,但是核函数不一定要选择径向基这一类函数。如果感觉这段话有点绕没关系,往下看就能慢慢体会了。

    为什么要将核函数和RBF神经网络放在一起,是希望学习它们的时候即能看到它们的联系又能找到其差别。

        一.由非线性映射引入核函数概念,之后介绍高斯径向基及其几何意义。

        预先规定是一个非线性映射函数,能够把空间中任一点,映射到空间

        下面先用一个例子说明这种映射的好处。

         例:假设二维平面上有一些系列样本点,他们的分布近似是一个围绕着原点的圆(见图1)。那么在这个二维的样本空间里,这些样本点满足的曲线方程为:

                                             

    如果设非线性映射为: 

                                             

    那么在映射后的的空间里,曲线方程变成了:   

                                     

    这意味着在新空间里,样本点是分布在一条近似直线上的,而不是之前的圆,很明显这是有利于我们的。

                       

                                                         图1.左图为原来的x所在的二维空间,右图为映射后的新的y空间

    继续这个例子,我们已经知道了映射关系,那么在y空间中的向量内积会是什么样子的呢?

                            

    注意公式里的各种括号。[x]代表样本x,圆括号(,)表示样本的坐标,尖括号<,>代表代表向量内积。

    由此我们知道y空间里两向量的内积,在x空间里确实一个关于的函数,这个k函数就称为核函数

          所以总结一下核函数就是:在原样本空间中非线性问题,我们希望通过一种映射把他映射到高维空间里使问题变得线性。然后在高维空间里使用我们的算法就能解决问题。当然这里按照前面的推导我们在高维空间里的运算是以向量内积为基础的。

          回顾SVM里的应用得到的分类器表达式为:

                                         

    x经过映射后得到的表达式为:

                                        

    由此就可以看到这里有高维空间里的内积,就能够用核函数代替这种内积了,而往往把高斯径向基函数作为核函数。

    高斯径向基函数公式如下:

                                     

    那么它有什么几何意义呢。

    先看看x经过映射以后,在高维空间里这个点到原点的距离公式:

                                       

    这表明样本x映射到高维空间后,存在于一个超球面上.

            接下来将讨论核函数为什么能映射到高维空间,径向基核又为什么能够映射到无限维空间。

    先考虑普通的多项式核函数:

                                 k(x, y) = (x^Ty)^2其中x, y \in \mathbb{R}^2,并且 x = (x_1, x_2), y = (y_1, y_2).

    因此这个多项式核函数能够写成:

                                 k(x, y) = (x_1y_1 + x_2y_2)^2= x_{1}^2y_{1}^2 + 2x_1x_2y_1y_2 + x_{2}^2y_{2}^2. 

    现在回到之前的映射

                           k(x, y) = \Phi(x)^T\Phi(y)

    并取  \Phi(x) = (x_1^2, \sqrt{2}x_1x_2, x_2^2),注意此时是3维空间了,那么有

                                 \Phi(x)^T\Phi(y) = x_1^2y_1^2 + 2x_1x_2y_1y_2 + x_2^2y_2^2 .

    这就是前面的k(x,y),因此,该核函数就将2维映射到了3维空间。

    看完了普通核函数由2维向3维的映射,再来看看高斯径向基函数会把2维平面上一点映射到多少维。

                                 k(x, y) = \exp(-\|x - y\|^2)
                                                 = \exp(- (x_1 - y_1)^2 - (x_2 - y_2)^2)
                                                 = \exp(- x_1^2 + 2x_1y_1 - y_1^2 - x_2^2 + 2x_2y_2 - y_2^2)
                                                 = \exp(-\|x\|^2) \exp(-\|y\|^2) \exp(2x^Ty) 

    呃,看看它的泰勒展开式你就会恍然大悟:

                                 k(x, y) = \exp(-\|x\|^2) \exp(-\|y\|^2) \sum_{n = 0}^{\infty} \frac{(2x^Ty)^n}{n!} 

    这个时候 \Phi(x)就是一个无限维的了。


    二、RBF神经网络

           最基本的径向基函数(RBF)神经网络的构成包括三层,其中每一层都有着完全不同的作用。输入层由一些感知单元组成,它们将网络与外界环境连接起来;第二层是网络中仅有的一个隐层,它的作用是从输入空间到隐层空间之间进行非线性变换,在大多数情况下,隐层空间有较高的维数;输出层是线性的,它为作用于输入层的激活模式提供响应。

            

    函数逼近的形式:

                            y(\mathbf{x}) = \sum_{i=1}^N w_i \, \phi(\|\mathbf{x} - \mathbf{x}_i\|),

         个人觉得,隐含层的每个节点就是就是空间中的一个基底,经过线性组合加权以后就变成了输出。这种理解是通过逼近理论来理解的。


    这里的多项式P就是由基底组成。

    隐含层每个节点对应的响应输出就像这些基底的相应一样,训练权值就是找到每个基底前面的系数。

          第二角度理解:

          不知大家是否熟悉混合高斯模型,这里的逼近有点像混合高斯模型。也就是每个高斯函数在自己的中心附近作出突出贡献。

                             

    在这里推介zouxy09的博文《径向基网络(RBF network)之BP监督训练》,他的文章演示的比较清楚。我摘抄如下:

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

                         

          我个人比较倾向径向基神经网络是把输入的样本映射到了另一个空间,在另一个空间经过线性组合后形成输出,得到逼近的结果,这种理解也有利于去窥探神经网络的本质。个人愚见,有错请指出。


    (转载请注明作者和出处:http://blog.csdn.net/heyijia0327 未经允许请勿用于商业用途)


    reference:

    1.Michael Eigensatz《Insights into the Geometry of the Gaussian Kernel and an Application in Geometric Modeling》

    2.Quora 上的问题 Why does the RBF (radial basis function) kernel map into infinite dimensional space?

    3.zouxy09 博文《径向基网络(RBF network)之BP监督训练

    4.如果想学SVM, JerryLead 的 《支持向量机》系列 当然不能漏掉.

    5.男神 Andrew Ng 的讲义是师祖.

    展开全文
  • 四.径向函数网络

    2019-10-02 08:04:32
    BP神经网络一种全局逼近网络,学习速度慢,本次介绍一种结构简单,收敛速度快,能够逼近任意非线性函数的网络——径向函数网络。(Radial Basis Function, RBF)根据生物神经元有局部响应原理而将基函数引入...

    BP神经网络是一种全局逼近网络,学习速度慢,本次介绍一种结构简单,收敛速度快,能够逼近任意非线性函数的网络——径向基函数网络。(Radial Basis Function, RBF)是根据生物神经元有局部响应的原理而将基函数引入到神经网络中。

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

    RBF是由三层构成的前向网络,第一层为输入层,节点个数等于输入的维数;第二层为隐含层,节点个数由问题复杂度而决定,第三层为输出层,节点数等于输出数据维度。

      第一层输入层:由信号源节点构成,仅起到数据信息的传递作用,对输入信息不做任何变换。

      第二层隐含层:节点数视需要而定。隐含层神经元核函数(作用函数)是高斯函数,对输入信息进行空间映射的变换。

      第三层输出层,对输入模式做出响应。输出层神经元的作用函数为线性函数,对隐含层神经元输出的信息进行线性加权后输出,作为整个神经网络的输出结果。

    RBF与多层感知器不同,不同层之间有不同的作用。隐藏层为采用径向基函数作为响应函数,从而将原本的输入空间转换到隐含空间,将线性不可分问题变得线性可分,输出层是线性的。

    径向基神经网络可以分为正则化网络和广义网络,两种差别不大,工程中常用的是广义网络,

     

    径向基函数

    所谓径向基函数 (Radial Basis Function 简称 RBF), 就是某种沿径向对称的标量函数。 通常定义为空间中任一点x到某
    一中心xc之间欧氏距离的单调函数 ,可记作 k(||x-xc||), 其作用往往是局部的 , 即当x远离xc时函数取值很小。

    最常用的径向基函数是高斯核函数 ,形式为 k(||x-xc||)=exp{- ||x-xc||^2/((2*σ)^2)) } 其中x_c为核函数中心,σ为函数的宽度参数 , 控制了函数的径向作用范围。如果x和x_c很相近那么核函数值为1,如果x和x_c相差很大那么核函数值约等于0。由于这个函数类似于高斯分布,因此称为高斯核函数,也叫做径向基函数(Radial Basis Function 简称RBF)。它能够把原始特征映射到无穷维。

    核函数有很多种,如线性核、多项式核、Sigmoid 核和 RBF(Radial Basis function)核。

    可以证明一定条件下,径向基函数几乎可以逼近所有的函数。

    径向基函数本身内容也十分丰富,有兴趣的话可以自己多多查阅。

     

    为什么RBF可以拟合任意函数呢

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

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

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

     

    正则化径向基函数网络

    由三层组成,第一层由输入节点组成,其个数等于输入向量的维度;第二层为隐含层,一个隐含节点对应一个训练数据,所以其个数等于训练数据点的个数,其激活函数为径向基函数,所以其输出为:Xi为基函数中心;输出层是线性单元,其个数为输出向量的维度。

     

    注意,输入层到隐含层的权值都为1,即所有的输入数据都完全输入隐含层中。这里面是并没有设置权值w的。

    正则化RBF网络的性质:

    • 是一个通用逼近器,只要有足够的隐藏节点,可以以任意精度逼近任意函数。
    • 给定一个未知的非线性函数F,总可以找到元组系数,使得网络对F的逼近最优
    • 若想要获得优秀性能,则隐含层神经元个数要很多,即需要很多训练数据,会导致很大的计算量,
    • 而一个矩阵越大,那么病态矩阵出现的概率也越大,所以求解方面出现极大地困难。

     

    广义网络

    正则化网络中,隐含层节点个数等于输入训练样本个数,所以如果选了样本个数很多,计算量很大。

    而一个矩阵越大,那么病态矩阵出现的概率也越大,所以求解方面出现极大地困难。

    所以用Galerkin方法来减少隐含层神经网络单元的个数,此时求得的是较低维度上的次优解。

     

    RBF学习算法

    求解的参数有3个:基函数的中心、方差以及隐含层到输出层的权值。(由不同层的作用选择不同的调整策略,隐含层根据非线性准则,输出层根据线性最优准则)

    根据基函数中心选取的不同,常见的有以下几种学习算法:

    (1)随机选取固定中心

    此种方法中,中心和标准差都固定了,唯一需要学习的是隐含层与输出层之间的权值。

    中心随机的从输入样本数据中选取且固定不变(当输入数据比较典型有代表性时,这是一种简单可行的方法)

    标准差: Dmax是选取中心之间的最大距离,n为隐含节点的个数,这样选取是为了防止径向基函数出现太尖或太平的情况。由此得到了基函数:

     

     

     

     

    (2)自组织选取中心学习方法:

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

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

      首先,选取h个中心做k-means(具体K-means见机器学习)聚类,对于高斯核函数的径向基,方差由公式求解:

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

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

      或者权值可以通过直接求伪逆,和随机选取固定中心法相同

      

    (3)有监督选取中心

      中心,方差,及权值都是通过误差来修正学习过程,可以很方便的采用梯度下降法。

    (4)正交最小二乘法(还没弄懂,后续更新)

     

    总结:由专家大量实验得出,中心位置采用无监督学习,输出权值采用监督学习的径向基函数网络推广能力不如多层感知器,而中心位置与权值均采用有监督学习的广义RBF网络优于多层感知机。

    所以对于RBF算法一般考虑用有监督选取中心方法作为其学习方法。

     

    RBF与多层感知器比较

    任意一个RBF都可以找到对应替代他的RBF,任意RBF也都可以找到替代他的多层感知器。

    • RBF是三层网络只有一个隐含层,而多层感知器可以有多个隐含层
    • RBF隐含层和输出层完全不同,隐含层采用非线性径向基函数作为基函数,而输出采用线性函数,两者作用不同。而多层感知器则一般度采用非线性函数。
    • RBF的基函数计算的是输入向量与基函数中心的欧式距离,使用局部指数衰减的非线性函数进行局部逼近,因此要达到同样的精度,径向基函数所需参数比多层感知机少得多。而多层感知器的隐藏单元计算输入向量与权值内积。
    • BP使用Sigmoid激励函数,输入有很大的可见域,RBF采用基函数,输入可见域很小,当输入值偏离基函数中心是,输出逐渐减小,并且很快趋于0,这一点符合神经元响应基于感受域这一理论基础。但是由于感受域很小,所以需要很多的径向基神经元。
    • BP神经网络的隐节点采用输入模式与权向量的内积作为激活函数的自变量,而激活函数采用Sigmoid函数。各调参数对BP网络的输出具有同等地位的影响,因此BP神经网络是对非线性映射的全局逼进,RBF神经网络的隐节点采用输入模式与中心向量的距离(如欧式距离)作为函数的自变量,并使用径向基函数(如Gaussian函数)作为激活函数。神经元的输入离径向基函数中心越远,神经元的激活程度就越低(高斯函数)。RBF网络的输出与部分调参数有关,譬如,一个wij值只影响一个yi的输出(参考上面第二章网络输出),RBF神经网络因此具有“局部映射”特性。所谓局部逼近是指目标函数的逼近仅仅根据查询点附近的数据。而事实上,对于径向基网络,通常使用的是高斯径向基函数,函数图象是两边衰减且径向对称的,当选取的中心与查询点(即输入数据)很接近的时候才对输入有真正的映射作用,若中心与查询点很远的时候,欧式距离太大的情况下,输出的结果趋于0,所以真正起作用的点还是与查询点很近的点,所以是局部逼近;而BP网络对目标函数的逼近跟所有数据都相关,而不仅仅来自查询点附近的数据。

     

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

     

    本文参考:https://www.cnblogs.com/pinking/p/9349695.html

    转载于:https://www.cnblogs.com/pythonlearing/p/9966273.html

    展开全文
  • 请问RBF(径向函数)中提到的mapping coefficients映射系数一般都有什么用,我现在 想做一个TPS变形的程序,网上给了一个版本,但是我搞不清楚映射系数什么的
  • 三、为什么RBF神经网络使用一个径向函数作为隐含层激活函数 四、参数训练 五、RBF网络vs BP网络和 SVM 一、什么是函数 著名傅里叶变换指:n个有参(权值)正、余弦三角函数和式可以等价表示...
  • 学习→创造→分享一直数行科技坚持原则,今天小数就来为大家分享一下RBF神经网络...径向函数神经网络一种高效前馈式神经网络,它具有其他前向网络所不具有最佳逼近性能和全局最优特性,并且结构简单,训...
  • 高斯核函数如何将低维向量映射到高维向量RBF 函数定义RBF 函数性质为什么 RBF 函数是将 x\mathbf{x}x 被映射到无穷维后构造核函数? RBF 函数定义 κ(x1,x2)=<ϕ(x1),ϕ(x2)>=exp⁡(−∣∣x1−x2∣∣22σ2)\...
  • (360图书馆你不是不让复制么...机器学习,具体以RBF网络里面函数为例,有童鞋说是通过径向基核函数可以把原始数据 投影到更高维空间里去(从而增加数据可分概率),对于这种说法,实在不是很理解(怎 么就...
  • 先讨论核函数是如何把数据映射到高维空间,然后引入径向基函数作核函数,并特别说明高斯径向基函数几何意义,以及它作为核函数时为什么能把数据映射到无限维空间。 2.提到了径向基函数,就继续讨论下径向基...
  • 前面讲解了什么是函数,以及有效核函数的要求,到这里基本上就结束了,很多博客也如此,但是呢这些只是理解支持向量机原理,如何使用它讲解却很少,尤其如何选择核函数更没有人讲,不讲也有原因,因为...
  • 文章目录什么是径向函数 什么是径向函数 理解RBF网络工作原理可从两种不同观点出发: 当用RBF网络解决非线性映射问题时,用函数逼近与内插观点来解释,对于其中存在不适定(illposed)问题,可用正则化...
  • SVM核函数的分类

    千次阅读 2017-10-27 11:28:21
    下列不是SVM核函数的是:多项式核函数logistic核函数径向基核函数Sigmoid核函数这道题答案logistic核函数。不要把这里sigmoid和logistic混淆了,为什么?看下面解释:支持向量机建立在统计学习理论基础之上...
  • RBF核函数的性质

    千次阅读 2020-04-06 12:43:02
    什么是径向基核函数:x到指定中心(原点)和指定一点(C_i)距离的函数形式。或者说:某种沿径向对称的标量函数。 RBF函数形式如下: 或者 其中,c_i指定中心点,而则代表RBF函数的作用范围,值越小,...
  • 关于核函数和SVM中结构风险最小化几点思考今天了解了一些RBF径向基(高斯)核函数问题,顺便又了解了一下SVM分类,从了解情况来看我对核函数是什么,为什么要用核函数以及SVM里结构风险最小化(Structure ...
  • RBF(径向基)神经网络

    千次阅读 2019-10-16 22:03:56
    什么是径向函数 RBF神经网络 RBF神经网络学习问题 RBF神经网络与BP神经网络区别 RBF神经网络与SVM区别 为什么高斯核函数就是映射到高维区间 前馈网络、递归网络和反馈网络 完全内插法 什么是径向基...
  • 【单选题】在下列四种型号滚动轴承中,只能承受径向载荷的是( )【单选题】一对齿轮传动中,两轮计算接触应力关系( )【单选题】与滚动轴承相比较,下述各点中,()不能作为滑动轴承优点。【单选题】两级平行轴...
  • 本文主要包括以下内容:什么是径向函数RBF神经网络RBF神经网络学习问题RBF神经网络与BP神经网络区别RBF神经网络与SVM区别为什么高斯核函数就是映射到高维区间前馈网络、递归网络和反馈网络完全内插法一、...
  • 但逻辑回归主要采用的是sigmoid函数,SVM有自己常用函数:linear线性核、rbf径向基、poly多项式 比方说,要对一堆香蕉和黄瓜进行分类~~~ 首先要明确的是,我们常见香蕉为黄色,黄瓜为绿色(为什么不叫绿瓜?...
  • 在《人工神经网络理论、设计及...说起径向基网络之前,我们先了解什么是径向函数径向基其实就是延径向对称标量函数,通常定义为空间任意点X到中心c之间欧式距离函数,我们可以看作d = (x-c)。接下来我们对d...
  • 径向基/RBF/高斯核 都是这种形式 为了感性理解,模拟一下。。。过程 高斯核本质 l1 l2 两个地标 ...本质是将原本数据,映射到一个无穷维空间(样本...γ作用是什么? 通过代码直观理解 #直观理解高斯核函数 import .
  • RBF全称Radial Basis Function,中文名称“径向函数”,辣么RBF神经网络就是径向函数神经网络了。是不是想到了一种核函数就叫RBF?没错,就是这货:衡量某个点到中心距离RBF神经网络啥?说白了就是以RBF作为...
  • 注意这些模型实际上都一种线性规划,前两个是径向距离函数,SBM是非径向的,一般认为SBM求解会更加好一点。后来,学者们在这些基础模型上不断衍生,不断加入更多限制条件去考虑问题,就出现了超效率模型,或者...
  • RBF是径向函数;而BP一般sigmoid函数 (或者Relu)。 局部逼近与全局逼近BP神经网络隐节点采用输入模式与权向量内积作为激活函数的自变量,而激活函数采用Sigmoid函数。各隐节点对BP网络输出具有同等地位...
  • 径向函数插值/核平滑就Python中可用实际解决方案而言,填充这些像素一种方法使用Scipy的径向函数插值实现(参见here),其目的对散乱数据进行平滑/插值。考虑到矩阵M和底层一维坐标数组r和c(这样M.shape...

空空如也

空空如也

1 2 3
收藏数 51
精华内容 20
关键字:

径向函数是什么的函数