精华内容
下载资源
问答
  • 径向基函数python
    千次阅读
    2021-01-30 12:35:15
    from scipy.linalg import norm, pinv
    from matplotlib import pyplot as plt
    import numpy
    
    
    class RBF:
        def __init__(self, indim, numcenters, outdim):
            self.indim = indim
            self.outdim = outdim
            self.numcenters = numcenters
            self.centers = [numpy.random.uniform(-1, 1, indim) for i in range(numcenters)]
            self.beta = 8
            self.W = numpy.random.random((numcenters, outdim))
    
        def _basisfunc(self, c, d):
            assert len(d) == self.indim
            return numpy.exp(-self.beta * norm(c - d) ** 2)
    
        def _calcAct(self, X):
            # calculate activations of RBFs
            G = numpy.zeros((X.shape[0], self.numcenters), float)
            for ci, c in enumerate(self.centers):
                for xi, x0 in enumerate(X):
                    G[xi, ci] = self._basisfunc(c, x0)
            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
            rnd_idx = numpy.random.permutation(X.shape[0])[:self.numcenters]
            self.centers = [X[i, :] for i in rnd_idx]
            print("center", self.centers)
            # calculate activations of RBFs
            G = self._calcAct(X)
            print(G)
            # calculate output weights (pseudoinverse)
            self.W = numpy.dot(pinv(G), Y)
    
        def test(self, X):
            """ X: matrix of dimensions n x indim """
            G = self._calcAct(X)
            Y = numpy.dot(G, self.W)
            return Y
    
    
    if __name__ == '__main__':
        n = 100
        x = numpy.mgrid[-1:1:complex(0, n)].reshape(n, 1)
        # set y and add random noise
        y = numpy.sin(3 * (x + 0.5) ** 3 - 1)
        # y += random.normal(0, 0.1, y.shape)
        # rbf regression
        rbf = RBF(1, 20, 1)
        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, numpy.zeros(rbf.numcenters), 'gs')
        # for c in rbf.centers:
        #     # RF prediction lines
        #     cx = numpy.arange(c - 0.7, c + 0.7, 0.01)
        #     cy = [rbf._basisfunc(numpy.array([cx_]), numpy.array([c])) for cx_ in cx]
        #     plt.plot(cx, cy, '-', color='black', linewidth=0.2)
        # plt.xlim(-1.2, 1.2)
        plt.show()
    
    
    更多相关内容
  • RBF网络 无需外部程序包的径向基函数网络的Python实现 结果
  • 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

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

    拟合函数F的重建问题满足以下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网相比,还有以下不同:

    径向基函数的中心不再限制在输入数据点上,而由训练算法确定。

    各径向基函数的扩展常数不再统一,而由训练算法确定。

    输出函数的线性变换中包含阈值参数,用于补偿基函数在样本集上的平均值与目标值之间的差别。

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

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

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

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

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

    dmax是所选数据中心之间的最大距离,M是数据中心的个数。扩展常数这么计算是为了避免径向基函数太尖或太平。

    自组织选择法,比如对样本进行聚类、梯度训练法、资源分配网络等。各聚类中心确定以后,根据各中心之间的距离确定对应径向基函数的扩展常数。

    λ是重叠系数。

    接下来求权值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

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    #include"matrix.h"

    using namespace std;

    const int P=100; //输入样本的数量

    vector X(P);//输入样本

    Matrix Y(P,1);//输入样本对应的期望输出

    const int M=10; //隐藏层节点数目

    vector center(M); //M个Green函数的数据中心

    vector delta(M); //M个Green函数的扩展常数

    Matrix Green(P,M); //Green矩阵

    Matrix 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

    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& center,double sample){

    int rect=-1;

    double dist=numeric_limits::max();

    for(int i=0;i

    if(fabs(sample-center[i])

    dist=fabs(sample-center[i]);

    rect=i;

    }

    }

    return rect;

    }

    /*计算簇的质心*/

    double calCenter(const vector &g){

    int len=g.size();

    double sum=0.0;

    for(int i=0;i

    sum+=g[i];

    return sum/len;

    }

    /*KMeans聚类法产生数据中心*/

    void KMeans(){

    assert(P%M==0);

    vector > group(M); //记录各个聚类中包含哪些样本

    double gap=0.001; //聚类中心的改变量小于为个值时,迭代终止

    for(int i=0;i

    center[i]=X[10*i+3]; //输入是均匀分布的,所以我们均匀地选取

    }

    while(1){

    for(int i=0;i

    group[i].clear(); //先清空聚类信息

    for(int i=0;i

    int c=nearest(center,X[i]);

    group[c].push_back(X[i]);

    }

    vector new_center(M); //存储新的簇心

    for(int i=0;i

    vector g=group[i];

    new_center[i]=calCenter(g);

    }

    bool flag=false;

    for(int i=0;i

    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

    for(int j=0;j

    Green.put(i,j,exp(-1.0*(X[i]-center[j])*(X[i]-center[j])/(2*delta[j]*delta[j])));

    }

    }

    }

    /*求一个矩阵的伪逆*/

    Matrix getGereralizedInverse(const Matrix &matrix){

    return (matrix.getTranspose()*matrix).getInverse()*(matrix.getTranspose());

    }

    /*利用已训练好的神经网络,由输入得到输出*/

    double getOutput(double x){

    double y=0.0;

    for(int i=0;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[]){

    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

    double d1=center[i]-center[i-1];

    double d2=center[i+1]-center[i];

    delta[i]=d1

    }

    calGreen();//计算Green矩阵

    Weight=getGereralizedInverse(Green)*Y;//计算权值矩阵

    //根据已训练好的神经网络作几组测试

    for(int x=-4;x<5;++x){

    cout<

    cout<

    cout<

    }

    return 0;

    }

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

    #include

    #include

    #include

    #include

    #include

    #include

    #include

    using namespace std;

    const int P=100; //输入样本的数量

    vector X(P);//输入样本

    vector Y(P);//输入样本对应的期望输出

    const int M=10; //隐藏层节点数目

    vector center(M); //M个Green函数的数据中心

    vector delta(M); //M个Green函数的扩展常数

    double Green[P][M]; //Green矩阵

    vector Weight(M); //权值矩阵

    const double eta=0.001;//学习率

    const double ERR=0.9;//目标误差

    const int ITERATION_CEIL=5000;//最大训练次数

    vector 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

    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 &vec,double floor,double ceil){

    for(int i=0;i

    vec[i]=uniform(floor,ceil);

    }

    /*根据网络,由输入得到输出*/

    double getOutput(double x){

    double y=0.0;

    for(int i=0;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

    error[i]=calSingleError(i);

    rect+=error[i]*error[i];

    }

    return rect/2;

    }

    /*更新网络参数*/

    void updateParam(){

    for(int j=0;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

    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()

    break;

    updateParam();//更新网络参数

    }

    cout<

    //根据已训练好的神经网络作几组测试

    for(int x=-4;x<5;++x){

    cout<

    cout<

    cout<

    }

    return 0;

    }

    展开全文
  • python实现径向基函数

    千次阅读 2018-10-20 22:39:35
    高斯核函数,主要的作用是衡量两个对象的相似度,当两个对象越接近,即a与b的距离趋近于0,则高斯核函数的值趋近于1,反之则趋近于0,换言之: 两个对象越相似,高斯核函数值就越大 作用: 用于分类时,衡量各个...

    1、生成数据集(双月数据集)

    class moon_data_class(object):
        def __init__(self,N,d,r,w):
            self.N=N
            self.w=w
            self.d=d
            self.r=r
        def sgn(self,x):
            if(x>0):
                return 1;
            else:
                return -1;
            
        def sig(self,x):
            return 1.0/(1+np.exp(x))
        
            
        def dbmoon(self):
            N1 = 10*self.N
            N = self.N
            r = self.r
            w2 = self.w/2
            d = self.d
            done = True
            data = np.empty(0)
            while done:
                #generate Rectangular data
                tmp_x = 2*(r+w2)*(np.random.random([N1, 1])-0.5)
                tmp_y = (r+w2)*np.random.random([N1, 1])
                tmp = np.concatenate((tmp_x, tmp_y), axis=1)
                tmp_ds = np.sqrt(tmp_x*tmp_x + tmp_y*tmp_y)
                #generate double moon data ---upper
                idx = np.logical_and(tmp_ds > (r-w2), tmp_ds < (r+w2))
                idx = (idx.nonzero())[0]
         
                if data.shape[0] == 0:
                    data = tmp.take(idx, axis=0)
                else:
                    data = np.concatenate((data, tmp.take(idx, axis=0)), axis=0)
                if data.shape[0] >= N:
                    done = False
            #print (data)
            db_moon = data[0:N, :]
            #print (db_moon)
            #generate double moon data ----down
            data_t = np.empty([N, 2])
            data_t[:, 0] = data[0:N, 0] + r
            data_t[:, 1] = -data[0:N, 1] - d
            db_moon = np.concatenate((db_moon, data_t), axis=0)
            return db_moon
    
    

    2、k均值聚类

    def k_means(input_cells, k_count):
        count = len(input_cells)      #点的个数
        x = input_cells[0:count, 0]
        y = input_cells[0:count, 1]
        #随机选择K个点
        k = rd.sample(range(count), k_count)
        
        k_point = [[x[i], [y[i]]] for i in k]   #保证有序
        k_point.sort()
    
        global frames
        #global step
        while True:
            km = [[] for i in range(k_count)]      #存储每个簇的索引
            #遍历所有点
            for i in range(count):
                cp = [x[i], y[i]]                   #当前点
                #计算cp点到所有质心的距离
                _sse = [distance(k_point[j], cp) for j in range(k_count)]
                #cp点到那个质心最近
                min_index = _sse.index(min(_sse))   
                #把cp点并入第i簇
                km[min_index].append(i)
            #更换质心
           
            k_new = []
            for i in range(k_count):
                _x = sum([x[j] for j in km[i]]) / len(km[i])
                _y = sum([y[j] for j in km[i]]) / len(km[i])
                k_new.append([_x, _y])
            k_new.sort()        #排序
          
    
            if (k_new != k_point):#一直循环直到聚类中心没有变化
                k_point = k_new
            else:
                return k_point,km
    

    3、高斯核函数
    高斯核函数,主要的作用是衡量两个对象的相似度,当两个对象越接近,即a与b的距离趋近于0,则高斯核函数的值趋近于1,反之则趋近于0,换言之:

    两个对象越相似,高斯核函数值就越大

    作用:
    用于分类时,衡量各个类别的相似度,其中sigma参数用于调整过拟合的情况,sigma参数较小时,即要求分类器,加差距很小的类别也分类出来,因此会出现过拟合的问题;
    用于模糊控制时,用于模糊集的隶属度。

    def gaussian (a,b, sigma):
        return np.exp(-norm(a-b)**2 / (2 * sigma**2))
    

    4、求高斯核函数的方差

     Sigma_Array = []
        for j in range(k_count):
            Sigma = []
            for i in range(len(center_array[j][0])):
                temp =  Phi(np.array([center_array[j][0][i],center_array[j][1][i]]),np.array(center[j]))
                Sigma.append(temp)
            Sigma = np.array(Sigma)
            Sigma_Array.append(np.cov(Sigma))
    

    5、显示高斯核函数计算结果

    gaussian_kernel_array = []
        fig = plt.figure()
        ax = Axes3D(fig)
        
        for j in range(k_count):
            gaussian_kernel = []
            for i in range(len(center_array[j][0])):
                temp =  Phi(np.array([center_array[j][0][i],center_array[j][1][i]]),np.array(center[j]))
                temp1 = gaussian(temp,Sigma_Array[0])
                gaussian_kernel.append(temp1)
            
            gaussian_kernel_array.append(gaussian_kernel)
     
            ax.scatter(center_array[j][0], center_array[j][1], gaussian_kernel_array[j],s=20)
        plt.show()
    

    6、运行结果

    在这里插入图片描述

    7、完整代码

    # coding:utf-8
    import numpy as np
    import pylab as pl
    import random as rd
    import imageio
    import math
    import random
    import matplotlib.pyplot as plt
    import numpy as np
    import mpl_toolkits.mplot3d
    from mpl_toolkits.mplot3d import Axes3D
    
    from scipy import *
    from scipy.linalg import norm, pinv
     
    from matplotlib import pyplot as plt
    random.seed(0)
    
    #定义sigmoid函数和它的导数
    def sigmoid(x):
        return 1.0/(1.0+np.exp(-x))
    def sigmoid_derivate(x):
        return x*(1-x) #sigmoid函数的导数
    
    
    class moon_data_class(object):
        def __init__(self,N,d,r,w):
            self.N=N
            self.w=w
          
            self.d=d
            self.r=r
        
       
        def sgn(self,x):
            if(x>0):
                return 1;
            else:
                return -1;
            
        def sig(self,x):
            return 1.0/(1+np.exp(x))
        
            
        def dbmoon(self):
            N1 = 10*self.N
            N = self.N
            r = self.r
            w2 = self.w/2
            d = self.d
            done = True
            data = np.empty(0)
            while done:
                #generate Rectangular data
                tmp_x = 2*(r+w2)*(np.random.random([N1, 1])-0.5)
                tmp_y = (r+w2)*np.random.random([N1, 1])
                tmp = np.concatenate((tmp_x, tmp_y), axis=1)
                tmp_ds = np.sqrt(tmp_x*tmp_x + tmp_y*tmp_y)
                #generate double moon data ---upper
                idx = np.logical_and(tmp_ds > (r-w2), tmp_ds < (r+w2))
                idx = (idx.nonzero())[0]
         
                if data.shape[0] == 0:
                    data = tmp.take(idx, axis=0)
                else:
                    data = np.concatenate((data, tmp.take(idx, axis=0)), axis=0)
                if data.shape[0] >= N:
                    done = False
            #print (data)
            db_moon = data[0:N, :]
            #print (db_moon)
            #generate double moon data ----down
            data_t = np.empty([N, 2])
            data_t[:, 0] = data[0:N, 0] + r
            data_t[:, 1] = -data[0:N, 1] - d
            db_moon = np.concatenate((db_moon, data_t), axis=0)
            return db_moon
    
    def distance(a, b):
        return (a[0]- b[0]) ** 2 + (a[1] - b[1]) ** 2
    #K均值算法
    def k_means(input_cells, k_count):
        count = len(input_cells)      #点的个数
        x = input_cells[0:count, 0]
        y = input_cells[0:count, 1]
        #随机选择K个点
        k = rd.sample(range(count), k_count)
        
        k_point = [[x[i], [y[i]]] for i in k]   #保证有序
        k_point.sort()
    
        global frames
        #global step
        while True:
            km = [[] for i in range(k_count)]      #存储每个簇的索引
            #遍历所有点
            for i in range(count):
                cp = [x[i], y[i]]                   #当前点
                #计算cp点到所有质心的距离
                _sse = [distance(k_point[j], cp) for j in range(k_count)]
                #cp点到那个质心最近
                min_index = _sse.index(min(_sse))   
                #把cp点并入第i簇
                km[min_index].append(i)
            #更换质心
           
            k_new = []
            for i in range(k_count):
                _x = sum([x[j] for j in km[i]]) / len(km[i])
                _y = sum([y[j] for j in km[i]]) / len(km[i])
                k_new.append([_x, _y])
            k_new.sort()        #排序
        
            if (k_new != k_point):#一直循环直到聚类中心没有变化
                k_point = k_new
            else:
                pl.figure()
                pl.title("N=%d,k=%d  iteration"%(count,k_count))
                for j in range(k_count):
                    pl.plot([x[i] for i in km[j]], [y[i] for i in km[j]], color[j%4])
                    pl.plot(k_point[j][0], k_point[j][1], dcolor[j%4])
                return k_point,km
        
    def Phi(a,b):
        return norm(a-b)
    
    def gaussian (x, sigma):
        return np.exp(-x**2 / (2 * sigma**2))
            
    if __name__ == '__main__':
        
        #计算平面两点的欧氏距离
        step=0
        color=['.r','.g','.b','.y']#颜色种类
        dcolor=['*r','*g','*b','*y']#颜色种类
        frames = []
        
        N = 200
        d = -4
        r = 10
        width = 6
            
        data_source = moon_data_class(N, d, r, width)
        data = data_source.dbmoon()
           # x0 = [1 for x in range(1,401)]
        input_cells = np.array([np.reshape(data[0:2*N, 0], len(data)), np.reshape(data[0:2*N, 1], len(data))]).transpose()
            
        labels_pre = [[1] for y in range(1, 201)]
        labels_pos = [[0] for y in range(1, 201)]
        labels=labels_pre+labels_pos
        
        
        k_count = 2 
        center,km = k_means(input_cells, k_count)
        test = Phi(input_cells[1],np.array(center[0]))
        print(test)
        test = distance(input_cells[1],np.array(center[0]))
        print(np.sqrt(test))
        count = len(input_cells)  
        x = input_cells[0:count, 0]
        y = input_cells[0:count, 1]
        center_array = []
    
        for j in range(k_count):
           
               center_array.append([[x[i] for i in km[j]], [y[i] for i in km[j]]])
        Sigma_Array = []
        for j in range(k_count):
            Sigma = []
            for i in range(len(center_array[j][0])):
                temp =  Phi(np.array([center_array[j][0][i],center_array[j][1][i]]),np.array(center[j]))
                Sigma.append(temp)
          
            Sigma = np.array(Sigma)
            Sigma_Array.append(np.cov(Sigma))
        
        gaussian_kernel_array = []
        fig = plt.figure()
        ax = Axes3D(fig)
        
        for j in range(k_count):
            gaussian_kernel = []
            for i in range(len(center_array[j][0])):
                temp =  Phi(np.array([center_array[j][0][i],center_array[j][1][i]]),np.array(center[j]))
                temp1 = gaussian(temp,Sigma_Array[0])
                gaussian_kernel.append(temp1)
            
            gaussian_kernel_array.append(gaussian_kernel)
            
            ax.scatter(center_array[j][0], center_array[j][1], gaussian_kernel_array[j],s=20)
        plt.show()
    
    展开全文
  • 本文实例讲述了Python实现的径向基(RBF)神经网络。分享给大家供大家参考,具体如下: from numpy import array, append, vstack, transpose, reshape, \ dot, true_divide, mean, exp, sqrt, log, \ loadtxt, ...
  • 以云南省2015年6月的29个气象站点数据为例进行径向基函数(Rbf)插值。数据格式如下: 今天需要使用到cartopy库来绘图,因此需要先安装好,据说安装很烦人,可以去uci下载.whl文件来安装,安装好后先测试一下是否可以...

    以云南省2015年6月的29个气象站点数据为例进行径向基函数(Rbf)插值。数据格式如下:

    今天需要使用到cartopy库来绘图,因此需要先安装好,据说安装很烦人,可以去uci下载.whl文件来安装,安装好后先测试一下是否可以运行,如下简单测试:

    首先,这是一个不成功的尝试,因为没能成功加载shp图层导致最后的插值没有落在特定的地理范围内。如果有伙伴知道这个问题的解决方法,希望不吝赐教。我相信只要是问题就一定存在解决方案。

    那么现在就开始今天的测试,首先还是老套路导入所需要的库或模块,如下:

    importnumpy asnp

    importpandas aspd

    fromscipy.interpolate importRbf

    importcartopy.crs asccrs

    importcartopy.feature ascfeat

    fromcartopy.io.shapereader importReader

    fromcartopy.mpl.gridliner importLONGITUDE_FORMATTER,LATITUDE_FORMATTER

    importmatplotlib.pyplot asplt

    然后设置能够正常显示中文和负号

    plt.rcParams['font.sans-serif']=['SimHei']#正常显示中文plt.rcParams['axes.unicode_minus']=False#正常显示负号

    接下来用pandas读取整理好的数据,使用的数据是云南省2015年6月的降水数据和气温数据,文中只测试了降水的Rbf插值。

    climate = pd.read_excel('yunnanclimate.xlsx',header=None,sep='\s+',names=['站号','lon','lat','降水','气温'])#print(climate)

    然后提取加载的xlsx数据里面的特定要素,比如经纬度,降水啥的

    #读取climate里面的具体数据lon =climate['lon']lat =climate['lat']rain_data =climate['降水']

    然后设置范围和格网化

    #设置经纬度范围slon =np.linspace(97.85,105.21,36)slat =np.linspace(21.45,28.50,36)slon,slat =np.meshgrid(slon,slat)

    接下来开始插值,function,我这里测试了3种,linear+cubic+gaussian,对于他们有啥区别哈哈,在最后我将分别展示这三种函数的模样

    #开始插值,使用径向基函数Rbffunc =Rbf(lon,lat,rain_data,function='cubic')rainX =func(slon,slat)

    接下来加载云南省的shp图层以及修改经纬度啥的信息,就是这个位置我出错了,如果有知道解决方案的还请不吝赐教。

    shp_path =r'D:\GeoCAS\Python\yunnan.shp'#设置绝对路径proj =ccrs.PlateCarree()#设置投影fig =plt.figure(figsize=(5,5),dpi=300)ax =fig.subplots(1,1,subplot_kw={'projection':proj})extent = [97.85,105.21,21.45,28.50]#限定经纬度范围reader =Reader(shp_path)#读取shp矢量yunnan =cfeat.ShapelyFeature(reader.geometries(),proj,edgecolor='k',facecolor='none')#设定shp特征ax.add_feature(yunnan,linewidth=0.5)ax.set_extent(extent,crs=proj)gl =ax.gridlines(crs=ccrs.PlateCarree(),draw_labels=True,linestyle='-')gl.xlabels_top=Falsegl.ylabels_right=Falsegl.xformatter =LONGITUDE_FORMATTER#以经纬度格式显示xy轴gl.yformatter =LATITUDE_FORMATTER

    gl.xlabel_style={'size':6}#设置xy字体大小gl.ylabel_style={'size':6}h =ax.contourf(slon,slat,rainX,cmap='viridis',extend='both')plt.colorbar(h,orientation='vertical')plt.show()

    最后得到的结果就是这样的,下面这是linear结果:

    接下来是cubic结果:

    最后就是Gaussian的结果,如下:

    就先到这儿吧,慢慢学,不要复制代码,一定要自己一个字母字母地输入,加油!

    ..................................................分割线(乞讨内容)............................................

    感谢您的关注,写文不易,如果这项测试对您有帮助,还望打赏,本穷鬼在此谢过,也希望与你一起交流学习进步。

    展开全文
  • 附件是径向基函数预测的代码,用Python编写,模型里添加了二次完全多项式程序,在采用二百个六维度的样本点训练预测时,误差在10%左右。
  • 本文主要包括以下内容:什么是径向基函数RBF神经网络RBF神经网络的学习问题RBF神经网络与BP神经网络的区别RBF神经网络与SVM的区别为什么高斯核函数就是映射到高维区间前馈网络、递归网络和反馈网络完全内插法一、...
  • 我试图按照CalTech lecture here的描述在Python和Numpy中实现径向基函数.数学对我来说似乎很清楚,所以我发现它不起作用(或似乎不起作用)很奇怪.这个想法很简单,一个人为每个高斯形式选择一个子采样中心的数量,形成一...
  • 基于径向基函数(RBF)的函数插值

    千次阅读 多人点赞 2020-07-07 01:16:19
    1. 函数插值 2. RBF函数插值 代码实现
  • 径向基函数(RBF)

    2021-04-06 16:13:35
    径向基函数是某种沿径向对称的标量函数,通常定义为样本到数据中心之间径向距离(通常是欧氏距离)的单调函数(由于距离是径向同性的)。 理解RBF网络的工作原理可从两种不同的观点出发: 当用RBF网络解决非线性...
  • 包含用于径向基函数(RBF)应用程序的工具的Python软件包。 应用包括内插散乱数据和求解不规则域上的偏微分方程(PDE)。 此软件包的大部分灵感来自Bengt Fornberg和Natasha Flyer的著作《径向基函数的底漆及其在...
  • 将matlab神经网络工具箱代码导出
  • 径向基函数RBF三维网格变形

    千次阅读 2020-12-14 18:56:30
    之前写过径向基函数(RBF)神经网络做分类或者拟合。然后挖了个坑说在《Phase-Functioned Neural Networks for Character Control》里面提到了用于做地形编辑,所以这篇博客就是解析一下如何用RBF做网格编辑系统。 ...
  • 解题思路 径向基函数插值的关键点在于径向基函数的选择和利用训练数据求解权重w。 3.代码实现 题目要求我们使用的RBF(径向基函数)是标准差为 0.1 的高斯函数:(宽度参数为0.1) 首先是根据题目要求获取训练集和...
  • 径向基函数分类

    千次阅读 2018-04-12 16:04:56
    大多数情况下,利用二维控件线性是无法分类的,这个时候就需要将维度提高,在更高阶的维度进行分类,径向基函数是变换到高纬度的方法之一。...python代码:#径向基函数,gamma=1/(2*σ)^2def rbf(v1,v2,gamma=10): ...
  • 径向基函数及RBF网络

    2021-11-18 13:45:37
    径向基函数 (RBF) 是多变量插值方法。 径向基函数的取值仅仅依赖于离原点距离的实值函数,Φ(x) = Φ(‖x‖),或者还可以是到任意一点c的距离,c点称为中心点,Φ(x,c) = Φ(‖x-c‖)。 任意满足 Φ(x) = Φ(‖x...
  • 本文将稍微介绍径向基函数的基础知识,之后以鸢尾花数据集为例,介绍三种RBFNN的权值更新方法(激活函数使用高斯函数),即:直接计算法,自组织选取法,有监督学习(梯度下降法),确定RBFNN的三部分权重(高斯函数...
  • 以上是对核函数的介绍,在本篇文章中将重点介绍径向基函数,这是一个非常简单但常见的核。 线性回归和 RBF(径向基函数) 在回归问题中,我们试图估计从 X 推断 Y 的最佳函数。如果 X 和 Y 之间存在非线性关系,则...
  • 本文是机器学习技法系列文章的第十四篇,介绍了径向基函数网络(Radial Basis Function Network,RBFNet),k近邻算法,k均指聚类算法。
  • python编写自己的RBF径向基神经网络

    千次阅读 热门讨论 2020-12-19 13:18:18
    根据径向基函数中心确定的方法不同,径向基神经网络有不同的学习策略。我们采用最常见的随机选取固定中心的方法。径向基函数记为: 一些神经网络的简介可以看这篇所有神经网络的特点及优缺点分析总结文章 一...
  • 调包偷个懒 import numpy as np from sklearn.datasets import load_iris from sklearn.metrics.pairwise import rbf_kernel import pandas as pd if __name__ == '__main__': X, y = load_iris(return_X_y=...
  • 1、基于径向基函数(RBF)的函数插值 2、径向基函数插值 —二维数据的插值 一、问题背景 许多物理和工程实际问题都可以用偏微分方程来描述,但是只有极少数的偏微分方程可以得到精确解,所以对于一般的偏微分方程,都...
  • RBF径向基函数简介

    千次阅读 2019-01-13 17:18:39
    1 理论 RBF网络就是使用一组径向基进行拟合。 ...1.2 径向基选几个来进行拟合函数? 一般是训练样本的个数。 1.3 拟合误差怎么算? 一般神经网络是,通过拟合误差来训练得到权值矩阵W。R...
  • 在机器学习中,(高斯)径向基函数核(英语:Radial basis function kernel),或称为RBF核,是一种常用的核函数。它是支持向量机分类中最为常用的核函数。[1] 关于两个样本x和x'的RBF核可表示为某个“输入空间”...
  • Python实现径向分布函数(RDF)的计算

    千次阅读 多人点赞 2020-03-25 19:30:43
    其实什么是径向分布函数(Radial distribution function)并不需要我去赘述,毕竟百度一搜一大堆。这里给出一个我第一接触RDF时看到的定义,图和公式给的也比较清楚,比较好理解:RDF定义再说明一点,代码所依靠的...

空空如也

空空如也

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

径向基函数python

友情链接: alexajj.rar