精华内容
下载资源
问答
  • rbfnn
    千次阅读
    2020-02-12 09:42:32

    RBF 就是计算两个点之间的相似度。

    真正把特征从低维空间映射到高维空间的是你选择的隐层的节点数,隐层的节点数就是高维空间的维数。

    如下实现了输入层到隐层之间文随机权重的径向基函数神经网络(RBFNN)

    def pairwise_distances(X, Y):
        D = -2 * X @ Y.T + np.sum(Y ** 2, axis=1) + np.sum(X ** 2, axis=1)[:, np.newaxis]
        D[D < 0] = 0
        return D
    
    class RBFNN:
        def __init__(self):
            self.N_i = None
            self.N_o = None
            self.N_h = 200
            self.sigma = 1
            self.beta = 1e-6
    
            
        def train(self, X, Y):
            self.N_i = X.shape[0]
            self.N_o = Y.shape[0]
            self.W_i = np.random.uniform(-self.sigma,self.sigma, (self.N_h, self.N_i))
            
            # 隐层输出
            H = np.exp(-pairwise_distances(self.W_i, X.T))
            
            self.W_o = Y.dot(H.T.dot(np.linalg.inv(H.dot(H.T)+self.beta*np.eye(self.N_h))))
         
        def predict(self, X):
            H = np.exp(-pairwise_l2_distances(self.W_i, X.T))
            return self.W_o.dot(H)
    

    在洛伦兹系统的动态重建实验上表现很好:

    np.random.seed()
    
    model = RBFNN()
    
    n = 1  # 使用 n 个历史点作为输入
    
    num_train = 3000
    x_train = np.vstack([select_samples(x,0+i,num_train) for i in range(n)])
    y_train = select_samples(x,n,num_train)
    
    model.train(x_train, y_train)
    
    num_test = 5000
    test_start = 5000
    P = np.empty((3,num_test))
    Q = select_samples(x,test_start, num_test)
    p = np.vstack([select_samples(x,test_start-n+i,1) for i in range(n)])
    
    
    for i in range(num_test):
        p_next = model.predict(p)
        P[:,i] = np.squeeze(p_next)
        p = np.vstack([p,p_next])[3:]
    
    
    fig = plt.figure()
    ax = fig.add_subplot(111, projection='3d')
    ax = fig.add_subplot()
    plt.plot(*P, 'r')
    plt.plot(*Q, 'g')
    
    plt.figure()
    dim = ['x','y','z']
    for i in range(3):
        plt.subplot(3,1,i+1)
        plt.plot(P[i,:].T, label='prediction')
        plt.plot(Q[i,:].T, label='true')
        plt.ylabel(dim[i])
        plt.legend(loc='upper right')
    

    在这里插入图片描述
    在这里插入图片描述

    更多相关内容
  • RBF网络的回归---实现非线性函数回归的实现
  • rbf网络matlab代码Julia·rbfnn 径向基函数神经网络(RBFNN)的Julia软件包 这是克里斯·麦考密克RBFNN()八度/ Matlab代码的翻译目前,Julia版本尚未优化,但运行速度提高了60%。 为了分配RBF神经元,使用了...
  • rbf_rbfnn_matlab_

    2021-10-01 01:08:33
    rbf neural network demo
  • 为了提高MSISP的控制精度,开发了一种基于径向基函数神经网络(RBFNN)的扰动补偿器来补偿扰动。 使用Lyapunov定理,可以在线更新RBFNN的权重矩阵。 因此,无需先验训练就可以构建RBFNN。 最后通过仿真和实验结果...
  • 基于PSO优化的径向基神经网络matlab程序,有注释,附带论文对原理进行说明,适合小白。
  • rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn rbfnn ...
  • 基于在线学习RBFNN的网络安全态势预测技术研究.pdf
  • 径向基底函数类神经网络(RBFNN),加入RBFNN来调整最佳的PID控制
  • 减法聚类算法结合RBFNN用于涡流检测中的缺陷检测与识别
  • 四旋翼飞机的自适应RBFNN /整体滑模控制
  • 利用该算法和BP算法、传统的RBFNN算法进行了剥离和擦伤识别的对比实验,结果表明:GA-RBFNN算法对剥离、擦伤和非损伤三类样本的测试集的识别率高于传统的RBFNN算法和BP算法,而且GA-RBFNN算法的进化代数远远小于BP...
  • RBF.rar_rbfnn_rbfnn matlab

    2022-09-14 22:40:01
    this file contains many matlab codes for RBFNN
  • 提出了一种优化选择径向基神经网络数据中心的算法,该算法结合了Kohonen网络的模式分类能力,将初步分类结果用做RBFNN的初始数据中心,然后采用OLS算法进行优化选择,对比仿真实验表明该算法效果比单独使用OLS算法...
  • 使用RBF神经网络实现函数逼近,逼近的函数为y(k)=u(k)^3+y(k-1)/(1+y(k-1)^2).通过对该程序的学习及实现可以更好的了解径向基神经网络的结构及算法
  • 因此,提出了一种基于委员会改进查询的主动学习算法,用于RBFNN,并将其应用于电子鼻,称为EQBC-RBFNN。 该技术有效地将QBC和RBFNN结合在一起,用于标记和有价值的未标记样品的电子鼻训练。 并且我们采用这种方法来...
  • RBFNN仿真训练程序.rar

    2022-07-02 21:09:00
    RBFNN仿真训练程序 Version 2.2 June 30 1999 Added conf.maxse field to plot_ras utility. Added info.gam (effective number of parameters) field for rbf_fs_2 and rbf_rr_2 methods. Some typos ...
  • RBF神经网络,用于系统辨识 很好的文件
  • RBFNN.rar,Train_Error.m,Test_Error.m,Model_Selection.m,preprocess.m,My_Width.m,My_Guass.m
  • 为识别固体燃料气化过程参数出现的异常模式(失稳),构建一种基于蜜蜂算法-径向基函数神经网络(BA-RBFNN)控制图模式识别的气化过程参数失稳监控模型,对气化过程参数进行监控。该监控模型主要包括特征描述、特征...
  • 本文将稍微介绍径向基函数的基础知识,之后以鸢尾花数据集为例,介绍三种RBFNN的权值更新方法(激活函数使用高斯函数),即:直接计算法,自组织选取法,有监督学习(梯度下降法),确定RBFNN的三部分权重(高斯函数...

    本文将稍微介绍径向基函数的基础知识,之后以鸢尾花数据集为例,介绍三种RBFNN的权值更新方法(激活函数使用高斯函数),即:直接计算法,自组织选取法,有监督学习(梯度下降法),确定RBFNN的三部分权重(高斯函数的中心和宽度,隐藏层与输出层之间的链接权)。

    鸢尾花数据集

    https://archive.ics.uci.edu/ml/index.php
    可从此处下载一些常用的简单的机器学习数据集,本文使用的鸢尾花数据集(将在最后的网盘链接中给出)包含三类,共150个样本,每条样本有4个属性,以csv文件的方式存储。
    在这里插入图片描述
    共有“Iris-setosa”、“Iris-versicolor”、“Iris-virginica”这三种不同的鸢尾花种类。我们的任务就是,通过训练集中的样本,建立一个能够解决鸢尾花三分类问题的径向基函数神经网络模型。
    首先,利用pandas读入数据,划分测试集和训练集。利用sklearn中的shuffle方法随机打乱数据后,取前130个样本作为训练集,后20个作为测试集。

    def loadData(filename):
        data = np.array(pd.read_csv(filename,header=None).values)
        lab=["Iris-setosa","Iris-versicolor","Iris-virginica"]
        for i in range(len(data)):
            for j in range(len(lab)):
                if data[i][-1]==lab[j]:
                    data[i][-1]=j
        data=shuffle(data)#打乱样本数据
        for i in range(4):#归一化
            data[:,i]=(data[:,i]-np.min(data[:,i]))/(np.max(data[:,i])-np.min(data[:,i]))
        train=np.array(data[:-20])
        test=np.array(data[-20:])
        return train,test
    

    径向基函数神经网络

    RBFNN的结构示意图:在这里插入图片描述
    高斯函数:
    在这里插入图片描述

    径向基函数神经网络的结构,与常规的BP网络的结构类似(看起来长得很像),不同的是,BP网络的激活函数是一个确定的函数,不含有待估参数,且其各层间的链接权都需要更新。而RBF网络输入层与隐藏层之间的链接权恒为1,不需要更新;隐藏层与输出层之间的链接权(权值矩阵)需要更新;隐藏层的节点,每个节点对应一个不同的激活函数(高斯函数的中心和方差不同),其方差和中心以矩阵形式表示,也需要确定。
    假设,我们要建立一个输入层有m个节点(与输入向量的维数相同),隐藏层有P个节点,输出层有n个节点(与待分类样本的类别数相同),选用高斯函数作为激活函数的径向基函数神经网络。则网络中存在P个高斯函数,我们也就需要确定P个中心(记为c),P个宽度(也就是方差,记为b),则c应该是一个维数为Pm的矩阵,b为维数为Pn的矩阵,隐藏层与输出层之间的链接权记为w,为一个P*n的矩阵。我们学习的目标就是确定一组c,b,w,使得模型能够对输入的样本确定其所属类别。

    一、直接计算法

    该方法好像有点极限学习机的意思。假设隐藏层每个节点所对应的激活函数的权值已知,也就是事先确定了一组c和b,只需再确定隐藏层与输出层的链接权w即可。
    我们随即初始化一组c,b,那么对于每一个样本其在隐藏层的输出也就确定了。我们希望模型(在训练集上的)的输出能够跟期望输出一致,我们知道网络的实际输出其实是隐藏层的输出向量(记为hidOut)与权值矩阵w的乘积,那么网络的预测值out=hidOutw,我们希望预测值out能与标签值T相同,也就是说w可由线性方程组hidOutw=T求出(w=inv(hidOut)*T),那么只要表示出隐藏层的输出矩阵hidOut,和标签矩阵T,之后令hidOut的伪逆矩阵与T做矩阵乘法即可,其结果就是我们确定的w。
    对于高斯函数的参数,继续使用一开始的时候随机初始化的那些值就可以,到这里,网络中的待估参数就都确定出来了,即可进行预测了。
    1.初始化权值c,b

    def init(inputnum,hiddennum,outnum):
        c=np.random.normal(0.0, 1, (hiddennum, inputnum))
        b=np.random.normal(0.0, 1, (hiddennum, 1))
        return c,b
    

    2.记录样本所对应的隐藏层输出和标签向量
    计算隐藏层的输出结果:

    def f(x,c,b):
        x=c-x
        X=[]
        for i in range(len(x)):
            X.append(-sum(x[i]*x[i])/(b[i]*b[i]))
        X=np.mat(X)
        return np.exp(X)
    

    记录样本所对应的隐藏层输出和标签向量

    	ho=[]
        T=[]
        for i in train:
            x=i[:-1]
            ho.append(f(x,c,b))
            lab=np.zeros(3)
            lab[i[-1]]+=1
            T.append(lab)
        T=np.array(T)
        ho=np.array(ho)
        ho=ho.reshape(130,10)
    

    3.计算伪逆矩阵,确定权值矩阵w
    利用numpy.linalg.pinv()得到矩阵的伪逆,之后用伪逆与T相乘得到w

    	hopiv=np.linalg.pinv(ho)
        w=np.dot(hopiv,T)
        w=w.T
    

    4.对模型进行测试

    #测试
        ans=[]
        for i in test:
            x=i[:-1]
            hout=f(x,c,b)
            out=np.dot(w,hout)
            if np.argmax(out)==i[-1]:
                ans.append(1)
            else:
                ans.append(0)
        print(sum(ans)/len(ans))
    

    经过测试发现,我们所确定的模型,在测试集上有良好的表现,其准确率基本能保持在80%~100%,说明我们的方法是行之有效的。
    测试十次,每次在不同测试集上的准确率如图所示。
    在这里插入图片描述
    参考代码如下:

    import pandas as pd 
    import numpy as np 
    from sklearn.utils import shuffle
    import matplotlib.pyplot as plt
    def loadData(filename):
        data = np.array(pd.read_csv(filename,header=None).values)
        lab=["Iris-setosa","Iris-versicolor","Iris-virginica"]
        for i in range(len(data)):
            for j in range(len(lab)):
                if data[i][-1]==lab[j]:
                    data[i][-1]=j
        data=shuffle(data)
        for i in range(4):
            data[:,i]=(data[:,i]-np.min(data[:,i]))/(np.max(data[:,i])-np.min(data[:,i]))
        train=np.array(data[:-20])
        test=np.array(data[-20:])
        return train,test
    #建立一个4个输入节点,3个输出节点,10个隐藏节点的RBFNN
    def init(inputnum,hiddennum,outnum):
        c=np.random.normal(0.0, 1, (hiddennum, inputnum))
        b=np.random.normal(0.0, 1, (hiddennum, 1))
        return c,b
    def f(x,c,b):
        x=c-x
        X=[]
        for i in range(len(x)):
            X.append(-sum(x[i]*x[i])/(b[i]*b[i]))
        X=np.mat(X)
        return np.exp(X)
    def Train():
        c,b=init(4,10,3)
        train,test=loadData("iris.csv")
        ho=[]
        T=[]
        for i in train:
            x=i[:-1]
            ho.append(f(x,c,b))
            lab=np.zeros(3)
            lab[i[-1]]+=1
            T.append(lab)
        T=np.array(T)
        ho=np.array(ho)
        ho=ho.reshape(130,10)
        hopiv=np.linalg.pinv(ho)
        w=np.dot(hopiv,T)
        w=w.T
        #测试
        ans=[]
        for i in test:
            x=i[:-1]
            hout=f(x,c,b)
            out=np.dot(w,hout)
            if np.argmax(out)==i[-1]:
                ans.append(1)
            else:
                ans.append(0)
        print(sum(ans)/len(ans))
        return sum(ans)/len(ans)
    
    def main():
        acc=[]
        for i in range(10):
            acc.append(Train())
        plt.bar(range(len(acc)),acc)
        plt.show()
        pass
    main()
    

    二、自组织选取中心学习法
    该方法与直接计算法的思想和步骤类似,只不过直接计算法是随机生成的P个高斯函数的中心和方差,而自组织选取是先通过聚类的方法,将训练集聚成P类,从而确定P个聚类中心,之后通过聚类中心再计算出P个方差,以此来确定隐藏层P个激活函数的参数,之后的步骤与直接计算法相同。
    1.利用K-means确定P个聚类中心

    def KNN(data,train_num=120,num=10,Flag=0.1):
        Center = [] #质心索引
        center = [] #质心数据
        result = np.full(train_num,-1)
        #防止初始化质心时重复
        def There_is_no(a):
            for i in Center:
                if a == i:
                    return False
            return True
        #随机选定num个初始质心,坐标保存到center中
        i=0
        while i<num:
            a = random.randint(0,train_num-1)
            if There_is_no(a):
                Center.append(a)
                i+=1
        for i in range(len(Center)):
            center.append(data[Center[i]])
            result[Center[i]]=i
        T=0
        rz_=0
        while True:
            T+=1
            #计算每一个样本的类别
            for i in range(train_num):
                flag = 0
                min = float("inf")
                for j in range(len(center)):
                    L = np.sqrt(np.sum((data[i]-center[j])**2))#欧氏距离
                    if min > L:
                        min = L
                        flag = j
                result[i] = flag
            #每一类样本重新计算质心:
            center_=np.array(result)
            rz=0
            for i in range(num):
                a = np.zeros(len(data[0]))
                count = 0
                for j in range(train_num):
                    if result[j] == i:
                        count+=1
                        a=np.add(a,data[j])
                center[i]=a/count
                rz+= np.sqrt(np.sum((center[i]-center_[i])**2))
            if abs(rz-rz_)<Flag:
                break
            rz_=rz
        return Center
    

    2.重写直接计算法的init()方法

    def init(inputnum,hiddennum,outnum,cIndex,Data):
        c=[]
        for i in cIndex:
            c.append(Data[i])
        c=np.array(c)
        b=[]
        for k in range(hiddennum):
            t=[]
            for i in range(len(c)):
                for j in range(len(c)):
                    t.append(np.linalg.norm(c[i]-c[j],2))
            b.append([sum(t)/hiddennum])
        b=np.array(b)
        return c,b
    

    之后的思路和步骤基本就与直接计算法相同了。
    同样记录十次模型的准确率,如下图所示,能够看出其效果较直接计算法有较大提升。
    在这里插入图片描述
    参考代码:

    import numpy as np
    import random
    from sklearn.utils import shuffle
    import pandas as pd 
    import matplotlib.pyplot as plt
    def KNN(data,train_num=120,num=10,Flag=0.1):
        Center = [] #质心索引
        center = [] #质心数据
        result = np.full(train_num,-1)
        #防止初始化质心时重复
        def There_is_no(a):
            for i in Center:
                if a == i:
                    return False
            return True
        #随机选定num个初始质心,坐标保存到center中
        i=0
        while i<num:
            a = random.randint(0,train_num-1)
            if There_is_no(a):
                Center.append(a)
                i+=1
        for i in range(len(Center)):
            center.append(data[Center[i]])
            result[Center[i]]=i
        T=0
        rz_=0
        while True:
            T+=1
            #计算每一个样本的类别
            for i in range(train_num):
                flag = 0
                min = float("inf")
                for j in range(len(center)):
                    L = np.sqrt(np.sum((data[i]-center[j])**2))#欧氏距离
                    if min > L:
                        min = L
                        flag = j
                result[i] = flag
            #每一类样本重新计算质心:
            center_=np.array(result)
            rz=0
            for i in range(num):
                a = np.zeros(len(data[0]))
                count = 0
                for j in range(train_num):
                    if result[j] == i:
                        count+=1
                        a=np.add(a,data[j])
                center[i]=a/count
                rz+= np.sqrt(np.sum((center[i]-center_[i])**2))
            if abs(rz-rz_)<Flag:
                break
            rz_=rz
        return Center
    def loadData(filename):
        fp = open(filename)
        data = np.array(pd.read_csv(filename,header=None).values)
        lab=["Iris-setosa","Iris-versicolor","Iris-virginica"]
        for i in range(len(data)):
            for j in range(3):
                if data[i][-1]==lab[j]:
                    data[i][-1]=j
        data=shuffle(data)
        for i in range(4):
            data[:,i]=(data[:,i]-np.min(data[:,i]))/(np.max(data[:,i])-np.min(data[:,i]))
        train=np.array(data[:-20])
        test=np.array(data[-20:])
        return train,test
    def init(inputnum,hiddennum,outnum,cIndex,Data):
        c=[]
        for i in cIndex:
            c.append(Data[i])
        c=np.array(c)
        b=[]
        for k in range(hiddennum):
            t=[]
            for i in range(len(c)):
                for j in range(len(c)):
                    t.append(np.linalg.norm(c[i]-c[j],2))
            b.append([sum(t)/hiddennum])
        b=np.array(b)
        return c,b
    def f(x,c,b):
        x=c-x
        X=[]
        for i in range(len(x)):
            X.append(-sum(x[i]*x[i])/(b[i]*b[i]))
        X=np.mat(X)
        return np.exp(X)
    def Train():
        train,test=loadData("iris.csv")
        knnData=train[:,:-1]
        Center = KNN(knnData,120,10,0.001)
        print(Center)
        c,b=init(4,10,3,Center,train[:,:-1])
        ho=[]
        T=[]
        for i in train:
            x=i[:-1]
            ho.append(f(x,c,b))
            lab=np.zeros(3)
            lab[i[-1]]+=1
            T.append(lab)
        T=np.array(T)
        ho=np.array(ho)
        ho=ho.reshape(130,10)
        hopiv=np.linalg.pinv(ho)
        w=np.dot(hopiv,T)
        w=w.T
        #测试
        ans=[]
        for i in test:
            x=i[:-1]
            hout=f(x,c,b)
            out=np.dot(w,hout)
            if np.argmax(out)==i[-1]:
                ans.append(1)
            else:
                ans.append(0)
        print(sum(ans)/len(ans))
        return sum(ans)/len(ans)
    def main():
        acc=[]
        for i in range(10):
            acc.append(Train())
        plt.bar(range(len(acc)),acc)
        plt.show()
        pass
    main()
    

    三、有监督学习(梯度下降法)
    前两种办法的无需训练,得到的模型基本就是数学解析解了,其性能(至少是在鸢尾花数据集上)应该是要比梯度下降法确定参数要优秀一些。
    用梯度下降法训练RBFNN,就是纯粹的反向传播算法了,先随机初始化待确定参数c,b,w之后通过模型对样本的误差通过梯度下降的办法来指导权值的更新。
    误差对c,b,w的梯度的表达式为:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    将上式用矩阵形式表出,更新权值的代码为:

        c=np.add(c,-lr*np.dot(np.dot(np.dot((w.T/(b*b)),err),hout.T),(c-x)))
        x_=x-c
        x_=np.mat([np.sum(i)*np.sum(i) for i in x_]).T
        b=np.add(b,-lr*np.dot(np.dot(np.dot(hout,err.T),(w.T/(b*b*b)).T),x_))
        w-=lr*np.dot(err,hout.T)
    

    应用梯度下降法,训练RBFNN的步骤为:
    1.参数初始化

    def init(inputnum,hiddennum,outnum):
        c=np.random.normal(0.0, 1, (hiddennum, inputnum))
        b=np.random.normal(0.0, 1, (hiddennum, 1))
        w=np.random.normal(0.0, 1, (outnum,hiddennum))
        return c,b,w
    

    2.前向计算,得到预测值

        hout=f(x,c,b)
        out=np.dot(w,hout)
    

    3.计算误差,并更新参数

        err=out-y
        c=np.add(c,-lr*np.dot(np.dot(np.dot((w.T/(b*b)),err),hout.T),(c-x)))
        x_=x-c
        x_=np.mat([np.sum(i)*np.sum(i) for i in x_]).T
        b=np.add(b,-lr*np.dot(np.dot(np.dot(hout,err.T),(w.T/(b*b*b)).T),x_))
        w-=lr*np.dot(err,hout.T)
        return float(sum(abs(err)))
    

    设置最大训练轮次为300轮,将每轮的平均损失和在测试集上的准确率可视化展示出来,如下图所示。最后的准确率基本稳定在95%左右。
    在这里插入图片描述
    上图所展示的模型的隐藏层节点数为25个(继续用10个隐藏层节点的话准确率远不如前两种方法)。而且梯度下降法确定一次模型参数的时间,就足够前两种方法确定100次模型了!(确实是较为耗时)

    参考代码如下

    import pandas as pd 
    import numpy as np 
    from sklearn.utils import shuffle
    import matplotlib.pyplot as plt
    def loadData(filename):
        fp = open(filename)
        data = np.array(pd.read_csv(filename,header=None).values)
        lab=["Iris-setosa","Iris-versicolor","Iris-virginica"]
        for i in range(len(data)):
            for j in range(3):
                if data[i][-1]==lab[j]:
                    data[i][-1]=j
        data=shuffle(data)
        for i in range(4):
            data[:,i]=(data[:,i]-np.min(data[:,i]))/(np.max(data[:,i])-np.min(data[:,i]))
        train=np.array(data[:-20])
        test=np.array(data[-20:])
        return train,test
    def init(inputnum,hiddennum,outnum):
        c=np.random.normal(0.0, 1, (hiddennum, inputnum))
        b=np.random.normal(0.0, 1, (hiddennum, 1))
        w=np.random.normal(0.0, 1, (outnum,hiddennum))
        return c,b,w
    def f(x,c,b):
        x=c-x
        X=[]
        for i in range(len(x)):
            X.append(-sum(x[i]*x[i])/(b[i]*b[i]))
        X=np.mat(X)
        return np.exp(X)
    def trainW(c,b,w,x,y,lr):
        hout=f(x,c,b)
        out=np.dot(w,hout)
        err=out-y
        c=np.add(c,-lr*np.dot(np.dot(np.dot((w.T/(b*b)),err),hout.T),(c-x)))
        x_=x-c
        x_=np.mat([np.sum(i)*np.sum(i) for i in x_]).T
        b=np.add(b,-lr*np.dot(np.dot(np.dot(hout,err.T),(w.T/(b*b*b)).T),x_))
        w-=lr*np.dot(err,hout.T)
        return float(sum(abs(err)))
    def Train():
        train,test=loadData("iris.csv")
        c,b,w=init(4,25,3)
        loss=[]
        acc=[]
        for e in range(300):
            loss_=[]
            for i in train:
                x=i[:-1]
                y=np.zeros((3,1))
                y[i[-1]]+=1
                loss_.append(trainW(c,b,w,x,y,0.01))
            loss.append(sum(loss_)/len(loss_))
            acc_=[]
            for i in test:
                x=i[:-1]
                y=np.zeros((3,1))
                y[i[-1]]+=1
                hout=f(x,c,b)
                out=np.dot(w,hout)
                if(np.argmax(out)==i[-1]):
                    acc_.append(1)
                else:
                    acc_.append(0)
            acc.append(sum(acc_)/len(acc_))
        plt.subplot(2,1,1)
        plt.plot(loss)
        plt.subplot(2,1,2)
        plt.plot(acc)
        print(acc)
        plt.show()
    Train()
    

    鸢尾花数据集
    样本个数也比较少,就直接贴出来吧

    5.1,3.5,1.4,0.2,Iris-setosa
    4.9,3.0,1.4,0.2,Iris-setosa
    4.7,3.2,1.3,0.2,Iris-setosa
    4.6,3.1,1.5,0.2,Iris-setosa
    5.0,3.6,1.4,0.2,Iris-setosa
    5.4,3.9,1.7,0.4,Iris-setosa
    4.6,3.4,1.4,0.3,Iris-setosa
    5.0,3.4,1.5,0.2,Iris-setosa
    4.4,2.9,1.4,0.2,Iris-setosa
    4.9,3.1,1.5,0.1,Iris-setosa
    5.4,3.7,1.5,0.2,Iris-setosa
    4.8,3.4,1.6,0.2,Iris-setosa
    4.8,3.0,1.4,0.1,Iris-setosa
    4.3,3.0,1.1,0.1,Iris-setosa
    5.8,4.0,1.2,0.2,Iris-setosa
    5.7,4.4,1.5,0.4,Iris-setosa
    5.4,3.9,1.3,0.4,Iris-setosa
    5.1,3.5,1.4,0.3,Iris-setosa
    5.7,3.8,1.7,0.3,Iris-setosa
    5.1,3.8,1.5,0.3,Iris-setosa
    5.4,3.4,1.7,0.2,Iris-setosa
    5.1,3.7,1.5,0.4,Iris-setosa
    4.6,3.6,1.0,0.2,Iris-setosa
    5.1,3.3,1.7,0.5,Iris-setosa
    4.8,3.4,1.9,0.2,Iris-setosa
    5.0,3.0,1.6,0.2,Iris-setosa
    5.0,3.4,1.6,0.4,Iris-setosa
    5.2,3.5,1.5,0.2,Iris-setosa
    5.2,3.4,1.4,0.2,Iris-setosa
    4.7,3.2,1.6,0.2,Iris-setosa
    4.8,3.1,1.6,0.2,Iris-setosa
    5.4,3.4,1.5,0.4,Iris-setosa
    5.2,4.1,1.5,0.1,Iris-setosa
    5.5,4.2,1.4,0.2,Iris-setosa
    4.9,3.1,1.5,0.1,Iris-setosa
    5.0,3.2,1.2,0.2,Iris-setosa
    5.5,3.5,1.3,0.2,Iris-setosa
    4.9,3.1,1.5,0.1,Iris-setosa
    4.4,3.0,1.3,0.2,Iris-setosa
    5.1,3.4,1.5,0.2,Iris-setosa
    5.0,3.5,1.3,0.3,Iris-setosa
    4.5,2.3,1.3,0.3,Iris-setosa
    4.4,3.2,1.3,0.2,Iris-setosa
    5.0,3.5,1.6,0.6,Iris-setosa
    5.1,3.8,1.9,0.4,Iris-setosa
    4.8,3.0,1.4,0.3,Iris-setosa
    5.1,3.8,1.6,0.2,Iris-setosa
    4.6,3.2,1.4,0.2,Iris-setosa
    5.3,3.7,1.5,0.2,Iris-setosa
    5.0,3.3,1.4,0.2,Iris-setosa
    7.0,3.2,4.7,1.4,Iris-versicolor
    6.4,3.2,4.5,1.5,Iris-versicolor
    6.9,3.1,4.9,1.5,Iris-versicolor
    5.5,2.3,4.0,1.3,Iris-versicolor
    6.5,2.8,4.6,1.5,Iris-versicolor
    5.7,2.8,4.5,1.3,Iris-versicolor
    6.3,3.3,4.7,1.6,Iris-versicolor
    4.9,2.4,3.3,1.0,Iris-versicolor
    6.6,2.9,4.6,1.3,Iris-versicolor
    5.2,2.7,3.9,1.4,Iris-versicolor
    5.0,2.0,3.5,1.0,Iris-versicolor
    5.9,3.0,4.2,1.5,Iris-versicolor
    6.0,2.2,4.0,1.0,Iris-versicolor
    6.1,2.9,4.7,1.4,Iris-versicolor
    5.6,2.9,3.6,1.3,Iris-versicolor
    6.7,3.1,4.4,1.4,Iris-versicolor
    5.6,3.0,4.5,1.5,Iris-versicolor
    5.8,2.7,4.1,1.0,Iris-versicolor
    6.2,2.2,4.5,1.5,Iris-versicolor
    5.6,2.5,3.9,1.1,Iris-versicolor
    5.9,3.2,4.8,1.8,Iris-versicolor
    6.1,2.8,4.0,1.3,Iris-versicolor
    6.3,2.5,4.9,1.5,Iris-versicolor
    6.1,2.8,4.7,1.2,Iris-versicolor
    6.4,2.9,4.3,1.3,Iris-versicolor
    6.6,3.0,4.4,1.4,Iris-versicolor
    6.8,2.8,4.8,1.4,Iris-versicolor
    6.7,3.0,5.0,1.7,Iris-versicolor
    6.0,2.9,4.5,1.5,Iris-versicolor
    5.7,2.6,3.5,1.0,Iris-versicolor
    5.5,2.4,3.8,1.1,Iris-versicolor
    5.5,2.4,3.7,1.0,Iris-versicolor
    5.8,2.7,3.9,1.2,Iris-versicolor
    6.0,2.7,5.1,1.6,Iris-versicolor
    5.4,3.0,4.5,1.5,Iris-versicolor
    6.0,3.4,4.5,1.6,Iris-versicolor
    6.7,3.1,4.7,1.5,Iris-versicolor
    6.3,2.3,4.4,1.3,Iris-versicolor
    5.6,3.0,4.1,1.3,Iris-versicolor
    5.5,2.5,4.0,1.3,Iris-versicolor
    5.5,2.6,4.4,1.2,Iris-versicolor
    6.1,3.0,4.6,1.4,Iris-versicolor
    5.8,2.6,4.0,1.2,Iris-versicolor
    5.0,2.3,3.3,1.0,Iris-versicolor
    5.6,2.7,4.2,1.3,Iris-versicolor
    5.7,3.0,4.2,1.2,Iris-versicolor
    5.7,2.9,4.2,1.3,Iris-versicolor
    6.2,2.9,4.3,1.3,Iris-versicolor
    5.1,2.5,3.0,1.1,Iris-versicolor
    5.7,2.8,4.1,1.3,Iris-versicolor
    6.3,3.3,6.0,2.5,Iris-virginica
    5.8,2.7,5.1,1.9,Iris-virginica
    7.1,3.0,5.9,2.1,Iris-virginica
    6.3,2.9,5.6,1.8,Iris-virginica
    6.5,3.0,5.8,2.2,Iris-virginica
    7.6,3.0,6.6,2.1,Iris-virginica
    4.9,2.5,4.5,1.7,Iris-virginica
    7.3,2.9,6.3,1.8,Iris-virginica
    6.7,2.5,5.8,1.8,Iris-virginica
    7.2,3.6,6.1,2.5,Iris-virginica
    6.5,3.2,5.1,2.0,Iris-virginica
    6.4,2.7,5.3,1.9,Iris-virginica
    6.8,3.0,5.5,2.1,Iris-virginica
    5.7,2.5,5.0,2.0,Iris-virginica
    5.8,2.8,5.1,2.4,Iris-virginica
    6.4,3.2,5.3,2.3,Iris-virginica
    6.5,3.0,5.5,1.8,Iris-virginica
    7.7,3.8,6.7,2.2,Iris-virginica
    7.7,2.6,6.9,2.3,Iris-virginica
    6.0,2.2,5.0,1.5,Iris-virginica
    6.9,3.2,5.7,2.3,Iris-virginica
    5.6,2.8,4.9,2.0,Iris-virginica
    7.7,2.8,6.7,2.0,Iris-virginica
    6.3,2.7,4.9,1.8,Iris-virginica
    6.7,3.3,5.7,2.1,Iris-virginica
    7.2,3.2,6.0,1.8,Iris-virginica
    6.2,2.8,4.8,1.8,Iris-virginica
    6.1,3.0,4.9,1.8,Iris-virginica
    6.4,2.8,5.6,2.1,Iris-virginica
    7.2,3.0,5.8,1.6,Iris-virginica
    7.4,2.8,6.1,1.9,Iris-virginica
    7.9,3.8,6.4,2.0,Iris-virginica
    6.4,2.8,5.6,2.2,Iris-virginica
    6.3,2.8,5.1,1.5,Iris-virginica
    6.1,2.6,5.6,1.4,Iris-virginica
    7.7,3.0,6.1,2.3,Iris-virginica
    6.3,3.4,5.6,2.4,Iris-virginica
    6.4,3.1,5.5,1.8,Iris-virginica
    6.0,3.0,4.8,1.8,Iris-virginica
    6.9,3.1,5.4,2.1,Iris-virginica
    6.7,3.1,5.6,2.4,Iris-virginica
    6.9,3.1,5.1,2.3,Iris-virginica
    5.8,2.7,5.1,1.9,Iris-virginica
    6.8,3.2,5.9,2.3,Iris-virginica
    6.7,3.3,5.7,2.5,Iris-virginica
    6.7,3.0,5.2,2.3,Iris-virginica
    6.3,2.5,5.0,1.9,Iris-virginica
    6.5,3.0,5.2,2.0,Iris-virginica
    6.2,3.4,5.4,2.3,Iris-virginica
    5.9,3.0,5.1,1.8,Iris-virginica
    

    一家之言,如有问题欢迎大家指出。

    展开全文
  • photovoltaic power forecasting RBFNN Spark cluster of similar days
  • 径向基函数神经网络(RBFNN)详解

    万次阅读 多人点赞 2019-09-13 16:29:05
    径向基函数神经网络(RBFNN) 前言 RBFNN是20世纪80年代末提出的一种单隐层、以函数逼近为基础的前馈神经网络。随着研究日渐成熟,RBFNN以其结构简单、非线性逼近能力强以及良好的推广能力,受到各领域研究者的极...

    参考:
    博客:深度学习之径向基函数神经网络RBFNN
    人工神经网络——径向基函数(RBF)神经网络
    youtube视频:RBF Networks

    一篇推荐:RBF神经网络理论与实现

    前言

    RBFNN是20世纪80年代末提出的一种单隐层、以函数逼近为基础的前馈神经网络。随着研究日渐成熟,RBFNN以其结构简单、非线性逼近能力强以及良好的推广能力,受到各领域研究者的极大关注,被广泛应用于模式分类、函数逼近和数据挖掘等众多研究领域。

    1.基础知识

    RBFNN全称为:Radial Basis Function Neyral Network。中文名为径向基函数神经网络。那么什么是径向基函数呢?

    1.1 径向基函数(RBF)

    看一下百度百科的解释:

    径向基函数是一个取值仅仅依赖于离原点距离的实值函数,也就是Φ(x)=Φ(‖x‖),或者还可以是到任意一点c的距离,c点称为中心点,也就是Φ(x,c)=Φ(‖x-c‖)。任意一个满足Φ(x)=Φ(‖x‖)特性的函数Φ都叫做径向基函数,标准的一般使用欧氏距离(也叫做欧式径向基函数),尽管其他距离函数也是可以的。在神经网络结构中,可以作为全连接层和ReLU层的主要函数。

    简单地说,就是该点的函数值只与该店距离中心点的距离有关。

    典型的径向基函数(RBF)有:
    (1):Gaussian函数
    在这里插入图片描述
    Alt
    (2):Multiquadric函数
    在这里插入图片描述
    (3):Inverse Multiquadric函数
    在这里插入图片描述
    形如Gaussian函数的RBF具有良好的局部特征,只在距离中心点附近的某一邻域内响应显著,而函数值随着与中心点的距离的增大而呈单调递减趋势,并逐渐趋近于0.因此这类RBF在实际应用中比较广泛。

    1.2 非线性问题

    我们知道,三层的神经网络就可以拟合任何一个函数。同样,RBFNN刚好三层且隐藏层使用径向基函数,所以,它完全可以拟合任何一个函数(只要隐藏层神经元足够多)。

    1.3 高级的径向基函数

    前面提到的几个径向基函数都是最简单形式的,在实际应用中,你可能使用高级的径向基函数。
    在这里插入图片描述

    其中,μt为中心点,σt为径基宽度。径基宽度决定了径向基函数下降的快慢,也可以说是圆的大小。比如:
    在这里插入图片描述

    图是视频中截取的,与上面的函数不对应。不过可以这样理解。

    1.4 RBFNN的结构

    RBFNN只有三层,第一层为输入层,第二层为隐藏层,第三层为输出层。输入层到隐藏层的神经元之间的权重全部为1。隐藏层是使用径向基函数作为激活函数的神经元。隐藏层与输出层之间就是普通的神经网络的连接关系,他们之间的权重可以训练而改变。
    在这里插入图片描述
    RBFNN的结构很简单。主要是它的原理部分。

    2.RBFNN的原理

    2.1基本原理

    假设我们要根据小球位置将下图中的小球分类,那么我们可以画两个圆,圆内的球全为红色,圆外的全为绿色。
    在这里插入图片描述
    在这里插入图片描述

    输入一个点的位置信息(x,y)坐标,隐藏层的两个神经元由于有不同的中心点,下降速度也不一样,那么,就会得到不同的输出,当然,离中心点越近,输出越大。这样我们就知道了输入的点离哪个中心点比较近,就可以知道它的颜色了。

    当然,实际中,数据分布可能不是那么理想,比如这样:
    在这里插入图片描述
    此时,我们用多个圆来拟合就可以了。这些圆有不同的μt和σt。
    在这里插入图片描述
    实际应用中,你可能用到几百几千个圆。而且,圆不再是理论上的这种断崖式的(圈内全为红球,圈外全为绿球),而是更加的平滑,毕竟径向基函数也是平滑的。
    在这里插入图片描述
    不同的径向基函数,球也不一样,下面是几种:

    对应到神经网络里,也就是我们有两个径向基函数,它们中心点不同,在距离中心点一定距离内为红球,大于这个距离为绿球。当然,两个径向基函数可能还需要进一步加权求和。
    在这里插入图片描述
    举一个手写数字识别的例子:
    在这里插入图片描述
    通过隐藏层的输出,我们直接就可以得知输入与数字7的中心点最近,所以,输入就被认为是数字7。
    但有时候,可能会得到这样不好的结果:
    在这里插入图片描述
    因为9可能和7有比较多的像素相像,所以9反而输出更高。这怎么办呢,我们把两个7的输出加起来就好了。
    在这里插入图片描述
    这也是为什么隐藏层与输出层之间的权重还要训练的原因。隐藏层的神经元数目实际上也更加多。比如30个隐藏层神经元的神经网络结构:
    在这里插入图片描述

    2.2径向基函数的确定

    RBFNN的关键就在于径向基函数的确定,中心点在哪,径基宽度多大,多少个径向基函数,都是会影响神经网络的效果的。

    径向基函数中心的确定方法有以下几种:

    • 直接计算法(随机选取RBF中心)

      隐含层神经元的中心是随机地在输入样本中选取,且中心固定。一旦中心固定下来,隐含层神经元的输出便是已知的,这样的神经网络的连接权就可以通过求解线性方程组来确定。适用于样本数据的分布具有明显代表性。

    • 自组织学习选取RBF中心法

      RBF神经网络的中心可以变化,并通过自组织学习确定其位置。输出层的线性权重则是通过有监督的学习来确定的。这种方法是对神经网络资源的再分配,通过 学习,使RBF的隐含层神经元中心位于输入空间重要的区域。这种方法主要采用K-均值聚类法来选择RBF的中心,属于无监督(导师)的学习方法。

    • 有监督学习选取RBF中心

      通过训练样本集来获得满足监督要求的网络中心和其他权重参数。常用方法是梯度下降法。

    • 正交最小二乘法选取RBF中心法

      正交最小二乘法(Orthogoal least square)法的思想来源于线性回归模型。神经网络的输出实际上是隐含层神经元某种响应参数(回归因子)和隐含层至输出层间连接权重的线性组合。所有隐含层神经元上的回归因子构成回归向量。学习过程主要是回归向量正交化的过程。

    2.3训练

    其实,和普通的神经网络一样,只不过,普通的神经网络训练的只是神经网络之间的权重,而RBFNN训练的还有激活函数----RBF的相关参数。这样理解起来就简单多了。

    展开全文
  • complete the coding for RBFNN Experiment Two: complete the coding for RBFNN by using the following method of calculating mu and sigma. Training data sets are provided There are three data sets: xor ...

    Experimental content

    • Experiment One: complete the coding for RBFNN
      在这里插入图片描述

    • Experiment Two: complete the coding for RBFNN by using the following method of calculating mu and sigma.
      在这里插入图片描述

    • Training data sets are provided
      There are three data sets: xor data, moon data and circle data. You can use one of the provided data to train and test your RBFNN, or you can conduct experiments on all the three data sets.

    Experimental results

    Gradient descent method

    # -*- coding: utf-8 -*-
    # @Time    : 2022/5/6 8:22
    # @Author  : sido
    # @FileName: RBF5.py
    # @Software: PyCharm
    
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib
    # 设置matplotlib正常显示中文和负号
    matplotlib.rcParams['font.sans-serif']=['SimHei']   # 用黑体显示中文
    matplotlib.rcParams['axes.unicode_minus']=False     # 正常显示负号
    
    
    np.random.seed(20)
    
    
    class RBF:
        def __init__(self, input_dim, hidden_node, out_dim, threshold=1.8, a=0.1, K=10):
            self.input_dim = input_dim  # 输入层的维度
            self.hidden_node = hidden_node  # 隐藏层的单元个数
            self.out_dim = out_dim  # 输出层的维度
            self.threshold = threshold  # 阈值,用于将输出结果处理为标签
            self.a = a  # 学习率
            self.Sigma = np.random.randn(hidden_node)  # 初始化sigma
            self.U = np.random.randn(hidden_node, input_dim)  # 初始化mu
            self.W = np.random.randn(hidden_node)  # 隐藏层到输出层的权重矩阵
            self.K = 10  # 训练退出条件
    
        def _basisfunc(self, c, d, ci):  # 激活函数
            return np.exp(-0.5 * (1 / self.Sigma[ci] ** 2) * np.linalg.norm(c - d) ** 2)
    
        def _calcAct(self, X):  # 计算通过激活函数的输出
            G = np.zeros(self.hidden_node, dtype=np.float64)
            for ci, c in enumerate(self.U):
                G[ci] = self._basisfunc(c, X, ci)
            return G
    
        def train(self, X, Y):  # 训练模型
            for k in range(self.K):  # 训练k次后退出
                for i in range(len(X)):
                    G = self._calcAct(X[i])
                    y_pred = G @ self.W
                    if y_pred > self.threshold:
                        y_pred = 2
                    else:
                        y_pred = 1
                    error = Y[i] - y_pred
                    for j in range(self.hidden_node):  # 计算梯度,并对参数进行更新
                        u = -self.W[j] / self.Sigma[j] ** 2 * error * G[j] * (X[i] - self.U[j])
                        sigma = -self.W[j] / self.Sigma[j] ** 3 * error * G[j] * np.dot((X[i] - self.U[j]), (X[i] - self.U[j]).T)
                        w = -error * G[j]
    
                        self.U[j] = self.U[j] - self.a * u
                        self.Sigma[j] = self.Sigma[j] - self.a * sigma
                        self.W[j] = self.W[j] - self.a * w
                if k % 1 == 0:
                    print("\n-------- k: ", k+1,
                          "\n-- centers: ", self.U,
                          "\n---- Sigma: ", self.Sigma,
                          "\n-------- W: ", self.W,
                          "\n")
                # self.W = np.linalg.pinv(G) @ Y
    
        def get_loss(self, Y_real, Y_pred):
            assert len(Y_real) == len(Y_pred), "标签Shape 不等于 预测Shape"
            loss = (Y_real - Y_pred) @ (Y_real - Y_pred).T / len(Y_real)
            return loss
    
    
        def predict(self, X):  # 预测输出
            G = np.zeros((X.shape[0], self.hidden_node), dtype=np.float64)
            for ci, c in enumerate(self.U):
                for xi, x in enumerate(X):
                    G[xi, ci] = self._basisfunc(c, x, ci)
            Y = G @ self.W
            for i in range(len(Y)):
                Y[i] = 1 if Y[i] < self.threshold else 2
            return Y
    
    
    if __name__ == '__main__':
        # ---------- 读取数据----------
        X_File_Path = "./Data/moon data/X.txt"
        Y_File_Path = "./Data/moon data/y.txt"
    
        with open(X_File_Path) as fx, open(Y_File_Path) as fy:
            X = fx.readlines()
            Y = fy.readlines()
    
            for i in range(len(X)):
                X[i] = list(X[i].split())
                X[i] = list(map(float, X[i]))
            Y = list(map(float, Y))
    
            X = np.array(X)
            Y = np.array(Y)
    
        # ---------- 训练模型并预测结果 ----------
        rbf = RBF(2, 5, 1)  # 实例化对象
        rbf.train(X, Y)  # 训练模型
        z = rbf.predict(X)  # 预测结果
        loss = rbf.get_loss(Y, z)
        print("loss: ", loss)
    
        # ---------- 结果可视化 ----------
        plt.figure(figsize=(6, 8))
        plt.suptitle("RBFNN", fontsize=28, color='r')
        ax = plt.subplot(211)
        ax.set_title("原始", loc="left", fontsize=18)
        plt.scatter(X[:, 0], X[:, 1], c=Y)
    
        ax = plt.subplot(212)
        ax.set_title("预测", loc="left", fontsize=18)
        plt.scatter(X[:, 0], X[:, 1], c=z)
        plt.show()
    

    Self-origanised method

    在这里插入图片描述

    random

    # -*- coding: utf-8 -*-
    # @Time    : 2022/5/5 23:16
    # @Author  : sido
    # @FileName: RBF4.py
    # @Software: PyCharm
    import numpy
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib
    # 设置matplotlib正常显示中文和负号
    matplotlib.rcParams['font.sans-serif']=['SimHei']   # 用黑体显示中文
    matplotlib.rcParams['axes.unicode_minus']=False     # 正常显示负号
    
    
    np.random.seed(20)
    
    
    class RBF:
        def __init__(self, input_dim, num_centers, out_dim, threshold=1.8):
            self.input_dim = input_dim
            self.num_centers = num_centers
            self.out_dim = out_dim
            self.beta = np.zeros(num_centers)
            self.centers = [np.random.uniform(-1, 1, input_dim) for i in range(num_centers)]
            self.W = np.random.random((num_centers, out_dim))
            self.threshold = threshold
    
        def _basisfunc(self, c, d, ci):
            return np.exp(-self.beta[ci] * np.linalg.norm(c-d)**2)
    
        def _calcAct(self, X):
            G = np.zeros((X.shape[0], self.num_centers), dtype=np.float64)
            for ci, c in enumerate(self.centers):
                for xi, x in enumerate(X):
                    G[xi, ci] = self._basisfunc(c, x, ci)
            return G
    
        def train(self, X, Y):
            rnd_idx = np.random.permutation(X.shape[0])[:self.num_centers]
            self.centers = [X[i, :] for i in rnd_idx]
    
            for i in range(self.num_centers):
                for j in range(self.num_centers):
                    c = np.linalg.norm(self.centers[i]-self.centers[j])
                    self.beta[i] = c / pow(2*self.num_centers, 0.5) if c > self.beta[i] else self.beta[i]
    
            G = self._calcAct(X)
    
            self.W = np.linalg.pinv(G) @ Y
    
        def predict(self, X):  # 预测输出
            G = np.zeros((X.shape[0], self.num_centers), dtype=np.float64)
            for ci, c in enumerate(self.centers):
                for xi, x in enumerate(X):
                    G[xi, ci] = self._basisfunc(c, x, ci)
            Y = G @ self.W
            for i in range(len(Y)):
                Y[i] = 1 if Y[i] < self.threshold else 2
            return Y
    
        def get_loss(self, Y_real, Y_pred):
            assert len(Y_real) == len(Y_pred), "标签Shape 不等于 预测Shape"
            loss = (Y_real - Y_pred) @ (Y_real - Y_pred).T / len(Y_real)
            return loss
    
    if __name__ == '__main__':
        # ---------- 读取数据----------
        X_File_Path = "./Data/moon data/X.txt"
        Y_File_Path = "./Data/moon data/y.txt"
    
        with open(X_File_Path) as fx, open(Y_File_Path) as fy:
            X = fx.readlines()
            Y = fy.readlines()
    
            for i in range(len(X)):
                X[i] = list(X[i].split())
                X[i] = list(map(float, X[i]))
            Y = list(map(float, Y))
    
            X = np.array(X)
            Y = np.array(Y)
    
        # ---------- 训练模型并预测结果 ----------
        rbf = RBF(2, 100, 1)  # 实例化对象
        rbf.train(X, Y)  # 训练模型
        z = rbf.predict(X)  # 预测结果
        loss = rbf.get_loss(Y, z)
        print("loss: ", loss)
    
        # ---------- 结果可视化 ----------
        plt.figure(figsize=(6, 8))
        plt.suptitle("RBFNN", fontsize=28, color='r')
        ax = plt.subplot(211)
        ax.set_title("原始", loc="left", fontsize=18)
        plt.scatter(X[:, 0], X[:, 1], c=Y)
    
        ax = plt.subplot(212)
        ax.set_title("预测", loc="left", fontsize=18)
        plt.scatter(X[:, 0], X[:, 1], c=z)
        plt.show()
    

    k-means

    # -*- coding: utf-8 -*-
    # @Time    : 2022/5/5 23:16
    # @Author  : sido
    # @FileName: RBF4.py
    # @Software: PyCharm
    import numpy
    import numpy as np
    import matplotlib.pyplot as plt
    import matplotlib
    from sklearn.cluster import KMeans
    # 设置matplotlib正常显示中文和负号
    matplotlib.rcParams['font.sans-serif']=['SimHei']   # 用黑体显示中文
    matplotlib.rcParams['axes.unicode_minus']=False     # 正常显示负号
    
    
    np.random.seed(20)
    
    
    class RBF:
        def __init__(self, input_dim, num_centers, out_dim, threshold=1.5):
            self.input_dim = input_dim
            self.num_centers = num_centers
            self.out_dim = out_dim
            self.beta = np.zeros(num_centers)
            self.centers = [np.random.uniform(-1, 1, input_dim) for i in range(num_centers)]
            self.W = np.random.random((num_centers, out_dim))
            self.threshold = threshold
    
        def _basisfunc(self, c, d, ci):
            return np.exp(-self.beta[ci] * np.linalg.norm(c-d)**2)
    
        def _calcAct(self, X):
            G = np.zeros((X.shape[0], self.num_centers), dtype=np.float64)
            for ci, c in enumerate(self.centers):
                for xi, x in enumerate(X):
                    G[xi, ci] = self._basisfunc(c, x, ci)
            return G
    
        def train(self, X, Y):
            kmeans = KMeans(n_clusters=self.num_centers, random_state=0).fit(X)
            self.centers = kmeans.cluster_centers_
    
            for i in range(self.num_centers):
                for j in range(self.num_centers):
                    c = np.linalg.norm(self.centers[i]-self.centers[j])
                    self.beta[i] = c / pow(2*self.num_centers, 0.5) if c > self.beta[i] else self.beta[i]
    
            G = self._calcAct(X)
    
            self.W = np.linalg.pinv(G) @ Y
    
        def predict(self, X):  # 预测输出
            G = np.zeros((X.shape[0], self.num_centers), dtype=np.float64)
            for ci, c in enumerate(self.centers):
                for xi, x in enumerate(X):
                    G[xi, ci] = self._basisfunc(c, x, ci)
            Y = G @ self.W
            for i in range(len(Y)):
                Y[i] = 1 if Y[i] < self.threshold else 2
            return Y
    
        def get_loss(self, Y_real, Y_pred):
            assert len(Y_real) == len(Y_pred), "标签Shape 不等于 预测Shape"
            loss = (Y_real - Y_pred) @ (Y_real - Y_pred).T / len(Y_real)
            return loss
    
    if __name__ == '__main__':
        # ---------- 读取数据----------
        X_File_Path = "./Data/moon data/X.txt"
        Y_File_Path = "./Data/moon data/y.txt"
    
        with open(X_File_Path) as fx, open(Y_File_Path) as fy:
            X = fx.readlines()
            Y = fy.readlines()
    
            for i in range(len(X)):
                X[i] = list(X[i].split())
                X[i] = list(map(float, X[i]))
            Y = list(map(float, Y))
    
            X = np.array(X)
            Y = np.array(Y)
    
        # ---------- 训练模型并预测结果 ----------
        rbf = RBF(2, 50, 1)  # 实例化对象
        rbf.train(X, Y)  # 训练模型
        z = rbf.predict(X)  # 预测结果
        loss = rbf.get_loss(Y, z)
        print("loss: ", loss)
    
        # ---------- 结果可视化 ----------
        plt.figure(figsize=(6, 8))
        plt.suptitle("RBFNN", fontsize=28, color='r')
        ax = plt.subplot(211)
        ax.set_title("原始", loc="left", fontsize=18)
        plt.scatter(X[:, 0], X[:, 1], c=Y)
    
        ax = plt.subplot(212)
        ax.set_title("预测", loc="left", fontsize=18)
        plt.scatter(X[:, 0], X[:, 1], c=z)
        plt.show()
    

    Training data sets are provided

    First method

    • moon data
      在这里插入图片描述
    • circle data
      在这里插入图片描述
    • xor data
      在这里插入图片描述

    Second method

    • moon data
      在这里插入图片描述
    • circle data
      在这里插入图片描述
    • xor data
      在这里插入图片描述

    Third method

    • moon data
      在这里插入图片描述
    • circle data
      在这里插入图片描述
    • xor data
      在这里插入图片描述

    Experimental analysis

    • 从实验的结果来看,在所给数据集下,第三种方法优于第二种方法,第二种方法优于第一种方法。
    • 三种方法在前两种类型的数据的效果比较不错
    • 第一中方法在moon data和circle data可以快速的收敛,只需要训练四到五轮就可以达到较好的预测结果,但在xor data上表现不佳,第一种方法需要调节四个参数,学习率a,推出条件k, 阈值threshhold和神经元个数hidden_out,在拟合第三种数据时,调节良久都未调节出一个好的预测结果,我以为有以下两个原因:
      • 一是需要调节的参数过多,难以调节
      • 二是没有实战经验,对参数调节没有直觉上的认识
      • 三是有可能这种方法不适合这种类型的数据(可能是我太菜了)
    • 第二种方法在对第三种数据的拟合效果优于第一种方法,但我通过仅仅调节神经元个数没法进一步提高拟合的效果,仅调节阈值和可能会使效果更差。同时调节二者难以找到一个平衡位置来使分类效果最好。
    • 第三种方法在三种数据上都有较好的性能,相较于第二种方法开销会更大,需要使用k-Means算法来找到mu。
    • 实验实现起来整体比较困难,无论是梯度下降中的前向传播和反向传播,公式的推导和矩阵等的运算都极其容易出错

    Conclusions

    虽然勉强完成实验的内容,但是实验还很多的缺陷。由于个人能力的问题,可能在公式推导、代码实现上还有很大的问题。如在梯度下降中没有计算训练过程中的损失,也没有可视化训练的损失。代码比较冗余,三种方法分别采用了三个python文件来实现,其中还有很多共用的代码。可以采用继承和方法重写等方法来减少重复的代码量。
    收获:

    • 在自己不断参考前人的博客,笔记,老师的ppt后,经过一下午不断的写代码,调试代码,终于基本实现的实验的内容,这是一个很大的收获。
    • 本来自己很不习惯用类,用面向对象的方法来写代码的,鉴于前面做实验都没有使用面向对象的方法来写代码,所以强制自己学并使用面向对象的方法来完成实验,期间也在b站,博客上学习了许多与面向对象相关的视频和文章,对面向对象的方法有了更深的理解。
    • 在代码的编写和调试的过程中也收获了许多,一是提高了代码的编写能力,二是尝试用pytharm中的debug来调试代码,减少了在需要查看的地方写print语句,导致代码量上升,代码也不美观。
    • 最后也在写代码的过程中有一些感悟,尽量不要去修改已有代码来适应输入的变化,尽量修改输入的样式来适应代码,不然可能导致代码越来越来,越改越错。
    展开全文
  • 针对高填路堤地基沉降难以预测这一技术难题,对其影响地基沉降的主要因素进行了分析,根据各因素之间存在的高度非线性,结合BC-RBFNN(基于聚类分析径向基函数神经网络)非线性拟合的特点,提出一种基于BC-RBNN模型对...
  • 介绍了RBFNN的结构leRBFNN应用于发动机SA的控制,并在SIMULINK下进行建模和仿真,编写SA数然后封装在SIMULINK系统中。RBFNN在发动机中的应用,为发动机SA的控制提供一种新的途径。
  • RBFNN算法在遥感土地分类中的应用
  • 复杂样本分类的GA-RBFNN方法,田津,李敏强 ,本文以提高径向基函数神经网络(RBFNN)分类能力为出发点,结合遗传算法(GA)群体并行搜索能力,提出了一种有效的GA-RBFNN学习算法。该算��
  • Laser Gyro Temperature Compensation Using Modified RBFNN
  • 基于PCA与合并聚类的RBFNN人脸识别.pdf

空空如也

空空如也

1 2 3 4 5 ... 13
收藏数 253
精华内容 101
关键字:

rbfnn