精华内容
下载资源
问答
  • 标准BP算法:求单个样本的均方误差(公式5.4); 参数更新非常频繁; 需要更多次数迭代。(这一点在loss曲线中可以明显看出来) 累积BP算法:求所有训练样例的均方误差(公式5.16); 参数更新频率低得多; 累积误差...
  • 5.5 试编程实现标准BP算法和累积BP算法,在西瓜数据集3.0上分别用这两个算法训练一个单隐层网络,并进行比较。 给定训练集D={(x1,y1),(x2,y2),......,(xm,ym)},其中输入示例由d个属性描述,输出l为实质向量。 图中...
    5.5 试编程实现标准BP算法和累积BP算法,在西瓜数据集3.0上分别用这两个算法训练一个单隐层网络,并进行比较。
    给定训练集D={(x1,y1),(x2,y2),......,(xm,ym)},其中输入示例由d个属性描述,输出l为实质向量。
    图中拥有d个输入神经元、l个输出神经元、q个隐层神经元的多层前馈网络结构。
    θj:表示输出层第j个神经元的阈值。
    γh:表示隐层第h个神经元的阈值。
    Vih:输入层第i个神经元与隐层第h个神经元直接的连接权值。
    Whj:隐层第h个神经元与输出层第j个神经元之间的连接权值。

    BP算法每次迭代都计算一个样本,最小化该样本输出值与真实值的差距,然后将修改过的参数传给下一个样本,直到达到收敛条件。这样做参数更新频繁,也可能出现参数更改相互抵消的情况,于是有了累积误差逆传播算法(ABP)。
    ABP算法每次迭代都会先算出所有样本的输出,然后最小化整个样本输出与真实值的最小平方和,修改参数后进行下一次迭代。ABP参数更新次数比BP算法少的多,但是当累积误差降到一定程度时,进一步下降会非常缓慢。
    迭代终止的条件:这里设置的终止条件是相邻一百次迭代的均方误差的差值不超过0.0001。
    BP算法MATLAB语言:
    clear
    
    x = xlsread('E:\machine_learning\BP\watermelon3.0.xlsx', 'Sheet1', 'A1:Q8');
    y = xlsread('E:\machine_learning\BP\watermelon3.0.xlsx', 'Sheet1', 'A9:Q9');
    x=x';     %x进行转置 
    y=y';     %y进行转置
    %将y设置为0,1两类
    y=y-1;
    %获取输入参数的样本数与参数数
    [m,d]=size(x);    %m是x矩阵的行数,表示总共有多少个训练集。d是矩阵的列数,表示训练集的输入。
    
    OutputLayerNum=1;  %输出层神经元
    
    v=rand(d,d+1);                      %输入层与隐层的权值,v是一个d行d+1列矩阵
    w=rand(d+1,OutputLayerNum);         %隐层与输出层的权值,w是一个d+1行1列矩阵
    gamma=rand(d+1);                    %隐层阈值,gamma是d+1行1列矩阵
    theta=rand(OutputLayerNum);         %输出层阈值,theta是1行1列矩阵
    py=zeros(m,OutputLayerNum);         %输出层输出
    b=zeros(d+1);                       %隐层输出
    g=zeros(OutputLayerNum);            %均方误差对w,gamma求导的参数
    e=zeros(d+1);                       %均方误差对v,theta求导的参数
    
    eta=1;                               %学习率
    
    
    kn=0;        %迭代的次数
    sn=0;        %同样的均方误差值累积次数
    previous_E=0; %前一次迭代的累计误差
    while(1)
        kn=kn+1;
        E=0;      %当前迭代的均方误差
        for i=1:m
          %计算隐层输出
          for j=1:d+1
            alpha=0;   %当前一个隐层节点神经元的输入
            for k=1:d
              alpha=alpha+v(k,j)*x(i,k);
             end
             b(j)=1/(1+exp(-alpha+gamma(j)));  %计算某个隐层节点的输出
           end
           %计算输出层输出
           for j=1:OutputLayerNum
             beta=0;
             for k=1:d+1
               beta=beta+w(k,j)*b(k);
             end
             py(i,j)=1/(1+exp(-beta+theta));
            end
            %计算当前一个训练数据的均方误差
            for j=1:OutputLayerNum
              E=E+((py(i,j)-y(i))^2)/2;
            end
            %计算w,beta导数参数
            for j=1:OutputLayerNum
              g(j)=py(i,j)*(1-py(i,j))*(y(i)-py(i,j));
            end
            %计算v,gamma导数参数
            for j=1:d+1
              teh=0;
              for k=1:OutputLayerNum
                teh=teh+w(j,k)*g(k);
              end
              e(j)=teh*b(j)*(1-b(j));
             end
             %更新v,gamma
             for j=1:d+1
               gamma(j)=gamma(j)+(-eta)*e(j);
               for k=1:d
                 v(k,j)=v(k,j)+eta*e(j)*x(i,k);
                end
               end
              %更新w,theta
              for j=1:OutputLayerNum
                theta(j)=theta(j)+(-eta)*g(j);
                for k=1:d+1
                  w(k,j)=w(k,j)+eta*g(j)*b(k);
                 end
               end
             end
             %迭代终止判断
             if(abs(previous_E-E)<0.0001)
                sn=sn+1;
                if(sn==100)
                   break;
                 end
              else
                 previous_E=E;
                 sn=0;
             end
     end
    西瓜3.0数据集在Excel中表示:


    训练权重结果:


    输出层输出结果:                                                                                                         真实结果:
                                                                                    

    这个实验的GitHub地址:https://github.com/Microstrong0305/Machine-Learning-ZhouZhiHua

    ABP(accumulated error backpropagation)算法:即为累积BP算法,累积BP算法直接针对累积误差最小化,它在读取整个训练集D一遍后才对参数进行更新,其参数更新的频率低得很,但是在很多任务中,累积误差下降到一定程度之后,进一步下降会非常缓慢,这时标准BP往往会更快获得较好的解,尤其是在训练集D非常大时更新明显。

    ABP算法的MATLAB实现:

    clear
    
    x = xlsread('E:\machine_learning\BP\watermelon3.0.xlsx', 'Sheet1', 'A1:Q8');
    y = xlsread('E:\machine_learning\BP\watermelon3.0.xlsx', 'Sheet1', 'A9:Q9');
    x=x';     %x进行转置 
    y=y';     %y进行转置
    %将y设置为0,1两类
    y=y-1;
    %获取输入参数的样本数与参数数
    [m,d]=size(x);    %m是x矩阵的行数,表示总共有多少个训练集。d是矩阵的列数,表示训练集的输入。
    
    OutputLayerNum=1;  %输出层神经元
    
    v=rand(d,d+1);                      %输入层与隐层的权值,v是一个d行d+1列矩阵
    w=rand(d+1,OutputLayerNum);         %隐层与输出层的权值,w是一个d+1行1列矩阵
    gamma=rand(d+1);                    %隐层阈值,gamma是d+1行1列矩阵
    theta=rand(OutputLayerNum);         %输出层阈值,theta是1行1列矩阵
    py=zeros(m,OutputLayerNum);         %输出层输出
    b=zeros(d+1);                       %隐层输出
    g=zeros(OutputLayerNum);            %均方误差对w,gamma求导的参数
    e=zeros(d+1);                       %均方误差对v,theta求导的参数
    
    eta=1;                               %学习率
    
    kn=0;        %迭代的次数
    sn=0;        %同样的均方误差值累积次数
    previous_E=0; %前一次迭代的累计误差
    while(1)
        kn=kn+1;
        E=0;      %当前迭代的均方误差
        %计算全部样本输出层输出
        for i=1:m
          %计算隐层的输出
          for j=1:d+1
            alpha=0;
            for k=1:d
              alpha=alpha+v(k,j)*x(i,k);
            end
            b(i,j)=1/(1+exp(-alpha+gamma(j)));
           end
           %计算输出层输出
           for j=1:OutputLayerNum
             beta=0;
             for k=1:d+1
               beta=beta+w(k,j)*b(i,k);
              end
              py(i,j)=1/(1+exp(-beta+theta(j)));
             end
            end
           %用来存储累积误差对四个变量的下降方向
           delta_v=zeros(d,d+1);
           delta_w=zeros(d+1,OutputLayerNum);
           delta_gamma=zeros(d+1);
           delta_theta=zeros(OutputLayerNum);
           %计算累积误差
           for i=1:m
             for j=1:OutputLayerNum
               E=E+((y(i)-py(i,j))^2)/2;
              end
              %计算w、theta导数参数
              for j=1:OutputLayerNum
                g(j)=py(i,j)*(1-py(i,j))*(y(i)-py(i,j));
              end
              %计算v、gamma导数参数
              for j=1:d+1
                teh=0;
                for k=1:OutputLayerNum
                  teh=teh+w(j,k)*g(k);
                end
                  e(j)=teh*b(i,j)*(1-b(i,j));
              end
              %计算w、theta导数
              for j=1:OutputLayerNum
                delta_theta=delta_theta+(-1)*eta*g(j);
                for k=1:d+1
                  delta_w(k,j)=delta_w(k,j)+eta*g(j)*b(i,k);
                end
              end
              %计算v、gamma导数
              for j=1:d+1
                gamma(j)= gamma(j)+(-1)*eta*e(j);
                for k=1:d
                  delta_v(k,j)=delta_v(k,j)+eta*e(j)*x(i,k);
                end
               end
              end
              %更新参数
              v=v+delta_v;
              w=w+delta_w;
             gamma=gamma+delta_gamma;
             theta=theta+delta_theta;
             %迭代终止条件
             if(abs(previous_E-E)<0.0001)
                sn=sn+1;
                if(sn==50)
                   break;
                end
              else
               previous_E=E;
               sn=0;
             end
    end

    训练的数据集还是西瓜数据集3.0,上边已经给出了。

    训练权重的结果:



    输出层输出的结果:                                                                                                       训练集数据的真实结果:                                                                        

                                                                                   


    这个实验的GitHub地址:https://github.com/Microstrong0305/Machine-Learning-ZhouZhiHua



    展开全文
  • 这里照着书上的公式,实现了一下标准BP算法和累积BP算法,BP是error Back Propagation的意思,误差逆传播。BP网络通常是指用BP算法训练的多层前馈神经网络。代码是照着书本公式自己写的,没有参考网上的其他版本。...

    这里照着书上的公式,实现了一下标准BP算法,和累积BP算法,BP是error Back Propagation的意思,误差逆传播。BP网络通常是指用BP算法训练的多层前馈神经网络。代码是照着书本公式自己写的,没有参考网上的其他版本。

    数据和代码地址:https://github.com/qdbszsj/BP

    具体的理论证明和公式推导,见西瓜书P101-104。这里重点说一下我的数据处理和一些代码细节,以及一些重点知识。

    西瓜数据集3.0,里面有离散属性,也有连续属性,除了密度、含糖量这样的属性,还有一些文字性描述的离散属性,因此我们先把离散属性转化为数字表示的属性。比如“色泽”这个属性下有三种属性:浅白、青绿、乌黑,我认为这三个属性有递进关系,类似于低中高,瘦均胖,因此就用一个值来表示他们,{0,0.5,1}这三个值表示这三个属性。同理,其他属性都用这种方法处理成0~1之间的小数。这里的属性都是有序的,没有无序的属性,如果有无序的属性,那么通常就要用一个K维的向量来表示,比如属性“瓜类”下分为“西瓜”、“黄瓜”、“南瓜”,显然这三个瓜是无序的,因此就用(0,0,1)、(0,1,0)、(0,0,1)这样的值来表示他们,其实就相当于把数据集拓宽了几列,列名由一个“瓜类”变为“是西瓜?”、“是黄瓜?”、“是南瓜?”,然后元素值是1和0。这里跟NLP的词向量处理方法有些接近,很多做NLP的词向量都是这样的。

    然后是根据书P104的伪代码,先初始化了两组权值(输入->隐层、隐层->输出)和两组阈值(隐层、输出),都是随机的0-1的小数,这里命名方式我都是按照书本上的变量名,P101都有。然后书上有一个公式没写出来,那就是b=f(alpha-gamma),这个跟公式5.3道理是一样的,自己的输出=sigmoid(自己接受到的输入-自己的阈值),这个“自己”可以是隐层或者是输出层。

    这里标准BP和累积BP我都实现了一下,区别很小,标准BP就是对于每一个输入的X个体,都更新一下网络,而累积BP就是把整个X集合都跑一遍,把各种要变化的值累加起来,再更新,累积BP类似于随机梯度下降法,每跑一遍整个集合,更新一次。

    隐层神经元的个数:这里我是用的d+1个,就是比输入结点的个数多一个,这个个数目前没有定论,通常是靠试错法来决定,几个结点表现好,就用几个。

    针对过拟合:通常有两种策略,一种就是“早停”,一边训练一边用测试集测试,如果发现训练集误差降低,而测试集误差升高,那么就停止训练。还有一种策略是“正则化”,根据书上公式5.17,误差评估时引入一个概念:网络的复杂程度。我们认为权值越小,网络约简单平滑,不容易过拟合,因此统计误差和网络复杂度都在误差评估的时候占一个百分比,which是一个可以调整的参数。

    这里发现numpy真好用,各种矩阵相乘、相加相减想乘,都一行代码搞定

    import pandas as pd
    import numpy as np
    dataset = pd.read_csv('/home/parker/watermelonData/watermelon_3.csv', delimiter=",")
    
    #according to P54--3.2
    #process the dataset
    attributeMap={}
    attributeMap['浅白']=0
    attributeMap['青绿']=0.5
    attributeMap['乌黑']=1
    attributeMap['蜷缩']=0
    attributeMap['稍蜷']=0.5
    attributeMap['硬挺']=1
    attributeMap['沉闷']=0
    attributeMap['浊响']=0.5
    attributeMap['清脆']=1
    attributeMap['模糊']=0
    attributeMap['稍糊']=0.5
    attributeMap['清晰']=1
    attributeMap['凹陷']=0
    attributeMap['稍凹']=0.5
    attributeMap['平坦']=1
    attributeMap['硬滑']=0
    attributeMap['软粘']=1
    attributeMap['否']=0
    attributeMap['是']=1
    del dataset['编号']
    dataset=np.array(dataset)
    m,n=np.shape(dataset)
    for i in range(m):
        for j in range(n):
            if dataset[i,j] in attributeMap:
                dataset[i,j]=attributeMap[dataset[i,j]]
            dataset[i,j]=round(dataset[i,j],3)
    
    trueY=dataset[:,n-1]
    X=dataset[:,:n-1]
    m,n=np.shape(X)
    
    #according to P101, init the parameters
    import random
    d=n   #the dimension of the input vector
    l=1   #the dimension of the  output vector
    q=d+1   #the number of the hide nodes
    theta=[random.random() for i in range(l)]   #the threshold of the output nodes
    gamma=[random.random() for i in range(q)]   #the threshold of the hide nodes
    # v size= d*q .the connection weight between input and hide nodes
    v=[[random.random() for i in range(q)] for j in range(d)]
    # w size= q*l .the connection weight between hide and output nodes
    w=[[random.random() for i in range(l)] for j in range(q)]
    eta=0.2    #the training speed
    maxIter=5000 #the max training times
    
    import math
    def sigmoid(iX,dimension):#iX is a matrix with a dimension
        if dimension==1:
            for i in range(len(iX)):
                iX[i] = 1 / (1 + math.exp(-iX[i]))
        else:
            for i in range(len(iX)):
                iX[i] = sigmoid(iX[i],dimension-1)
        return iX
    
    
    # do the repeat----standard BP
    while(maxIter>0):
        maxIter-=1
        sumE=0
        for i in range(m):
            alpha=np.dot(X[i],v)#p101 line 2 from bottom, shape=1*q
            b=sigmoid(alpha-gamma,1)#b=f(alpha-gamma), shape=1*q
            beta=np.dot(b,w)#shape=(1*q)*(q*l)=1*l
            predictY=sigmoid(beta-theta,1)   #shape=1*l ,p102--5.3
            E = sum((predictY-trueY[i])*(predictY-trueY[i]))/2    #5.4
            sumE+=E#5.16
            #p104
            g=predictY*(1-predictY)*(trueY[i]-predictY)#shape=1*l p103--5.10
            e=b*(1-b)*((np.dot(w,g.T)).T) #shape=1*q , p104--5.15
            w+=eta*np.dot(b.reshape((q,1)),g.reshape((1,l)))#5.11
            theta-=eta*g#5.12
            v+=eta*np.dot(X[i].reshape((d,1)),e.reshape((1,q)))#5.13
            gamma-=eta*e#5.14
        # print(sumE)
    
    # #accumulated BP
    # trueY=trueY.reshape((m,l))
    # while(maxIter>0):
    #     maxIter-=1
    #     sumE=0
    #     alpha = np.dot(X, v)#p101 line 2 from bottom, shape=m*q
    #     b = sigmoid(alpha - gamma,2)  # b=f(alpha-gamma), shape=m*q
    #     beta = np.dot(b, w)  # shape=(m*q)*(q*l)=m*l
    #     predictY = sigmoid(beta - theta,2)  # shape=m*l ,p102--5.3
    #
    #     E = sum(sum((predictY - trueY) * (predictY - trueY))) / 2  # 5.4
    #     # print(round(E,5))
    #     g = predictY * (1 - predictY) * (trueY - predictY)  # shape=m*l p103--5.10
    #     e = b * (1 - b) * ((np.dot(w, g.T)).T)  # shape=m*q , p104--5.15
    #     w += eta * np.dot(b.T, g)  # 5.11 shape (q*l)=(q*m) * (m*l)
    #     theta -= eta * g  # 5.12
    #     v += eta * np.dot(X.T, e)  # 5.13 (d,q)=(d,m)*(m,q)
    #     gamma -= eta * e  # 5.14
    
    
    def predict(iX):
        alpha = np.dot(iX, v)  # p101 line 2 from bottom, shape=m*q
        b=sigmoid(alpha-gamma,2)#b=f(alpha-gamma), shape=m*q
        beta = np.dot(b, w)  # shape=(m*q)*(q*l)=m*l
        predictY=sigmoid(beta - theta,2)  # shape=m*l ,p102--5.3
        return predictY
    
    print(predict(X))



    展开全文
  • 标准BP算法和累计BP算法的区别

    千次阅读 2020-02-23 17:55:05
     累积 BP 算法标准 BP 算法都很常用.一般来说,标准 BP 算法每次更新只针对单个样例?参数更新得非常频繁,而且对不同样例进行更新的效果可能出现"抵消"现象.因此,为了达到同样的累积误差极小点 标准 BP 算法往往...

    引用机器学习书上的解释:  

      累积 BP 算法与标准 BP 算法都很常用.一般来说,标准 BP 算法每次更新只针对单个样例?参数更新得非常频繁,而且对不同样例进行更新的效果可能出现"抵消"现象.因此,为了达到同样的累积误差极小点 标准 BP 算法往往需进行更多次数的法代.累积 BP 算法直接针对累积误差最小化,它在 卖取整个训练集 一遍后才对参数进行更新,其参数更新的频率低得多.但在很多任务中,累积误差下降到一定程度之后,进一步下降会非常缓慢,这时标准 BP 往往会更快获得较好的解,尤其是在训练非常大时更明显.

      标准 BP 算法和累积 BP算法的区别类似于随机梯度下降(stochastic gradient descent ,简称 SGD) 与标准梯度下降之间的区别.

     

    展开全文
  • 机器学习——神经网络累积BP算法

    千次阅读 2018-04-24 16:13:07
    在上篇的博客介绍的“标准BP算法”每次仅...累积BP算法与标准BP算法都很常用(标准BP算法和累积BP算法的区别类似于随机梯度下降(Stochastic gradient descent,简称 SGD)于标准梯度下降之间的区别)。一般来说,标...

    在上篇的博客介绍的“标准BP算法”每次仅针对一个训练样例更新连接权和阈值,也就是说,BP算法中的更新规则是基于单个的这里写图片描述 推导而得,如果类似的推导出基于累积误差最小化的更新规则,就得到了累积误差逆传播算法。累积BP算法与标准BP算法都很常用(标准BP算法和累积BP算法的区别类似于随机梯度下降(Stochastic gradient descent,简称 SGD)于标准梯度下降之间的区别)。一般来说,标准BP算法每次更新只针对单个样例,参数更新得非常频繁,而且对不同样例进行更新的效果可能出现“抵消”现象。因此,为了达到同样的累积误差极小点,标准BP算法往往需要更多次数的迭代。累积BP算法直接针对累积误差最小化,它在读取整个训练集D一遍之后才对参数进行更新,其参数更新的频率低的多。但在很多任务中,累积误差下降到一程度之后,进一步下降会非常缓慢,这时标准BP往往会更快获得较好的理解,尤其是训练集D非常大时更明显。

    正是由于其强大的表示能力,BP神经网络经常遭遇过拟合,其训练误差持续降低,但测试误差却可能上升。
    通常有两种策略来缓解BP网络的过拟合。第一种策略是“早停”(early stopping):将数据分成训练集合验证集,训练集用来计算梯度、更新连接权和阈值,验证集用来估计误差,若训练集误差降低但验证集误差升高,则停止训练,同时返回具有最小验证集误差的连接权和阈值。第二种策略是“正则化”(regularization),其基本思想是在误差目标函数中增加一个用于描述网络复杂度的部分,例如连接权和阈值的平方和。仍令这里写图片描述 表示第k个训练样例上的误差,这里写图片描述 表示连接权和阈值,则误差目标函数(5.16)改变为
    这里写图片描述
    其中,这里写图片描述 用于对经验误差与网络复杂度这两项进行折中,常通过交叉验证法来估计。

    参考:
    《机器学习》 周志华 著

    展开全文
  • 编码实现标准BP算法和累积BP算法,在西瓜数据集3.0上分别用这两个算法训练一个单隐层网络,并进行比较 import pandas as pd import numpy as np from sklearn.preprocessing import LabelEncoder from sklearn....
  • 习题5.5: 试编程实现标准BP算法和累积BP算法,在西瓜数据集3.0上分别用这两个算法训练一个单隐层网络,并进行比较算法的主要思想来自周志华《机器学习》上讲BP算法的部分,实现了书上介绍的标准BP算法和累积BP算法,...
  • 标准BP算法和累积BP算法的比较 标准BP算法每次只针对单个样例,参数更新得非常频繁,而且对不同样例进行更新的效果可能出现“抵消”现象。因此,为了达到同样的累积误差极小点,标准BP算法往往需要进行更多次数的...
  • 误差逆传播算法(BP算法)4.1 BP算法具体推导4.2 标准BP算法和累积BP算法4.3 BP神经网络过拟合4.4 全局最小和局部最小5. 神经网络的各种常用算法5.1 RBF网络5.2 ART网络5.3 SOM网络5.4 级联相关网络5.5 Elman网络...
  • 反向传播算法

    2018-10-24 21:24:24
    标准BP算法:每次都是对每个样本进行更新参数,更新频繁,有时对不同的样本进行参数的更新时,可能出现“抵消”的现象。 累积BP算法:每进行完一轮之后再进行更新,直接针对累积误差最小化。、   BP神经网络防止...
  • 为了解决神经网络过训练和经验公式确定网络结构盲目性的问题,更好地实现对高填土涵洞结构应力预测研究,结合遗传算法和BP网络两种智能方法各自优点开发出自适应遗传算法-神经网络(AGABP)系统。该系统引进自适应...
  • 标准BP算法和累积BP算法对比实验(comparative experiment of BP)(code here); BP算法改进(improvement of BP algorithm)(code here); RBF神经网络实现(implementation of RBF network)(code here); SOM神经...
  • 机器学习-周志华-课后习题答案5.5

    千次阅读 2017-03-17 21:39:34
    5.5 试编程实现标准BP算法和累计BP算法,在西瓜数据集3.0上分别用这两个算法训练一个单隐层网络,并进行比较。 通过编程实践发现,在本例下要达到某一限定的均方误差时,标准BP算法比累积BP算法明显收敛更快,特别在...
  • 机器学习第五章

    2017-11-20 16:24:53
    今天看了《机器学习》的第五章神经网络部分。本章主要讲述的是: ...3.比较经典的神经网络的算法是BP算法(标准BP算法累积BP算法)。一般情况下的BP算法网络指的是训练多层(指的是隐层的层数)前反
  • 课后题5.5:编程实现一个标准bp算法和一个累积bp算法,用这两个算法训练一个带有单隐层的网络,并给出在西瓜数据集3.0上的效果 首先,单隐层网络,就是输入和输出层之间只有一层神经元的网络,见西瓜书P102图 5.7所...
  • 西瓜笔记(四下)

    2018-10-12 23:43:00
    前文所讲的标准BP算法每次只针对一个训练集中的一个样例。权值阈值更新的比较频繁,但是对不同的样例进行更新的效果可能出现“抵消”现象。因此,为了达到同样的累积误差极小点,累积BP算法直接针对累积误差最小化...
  • 编程实现标准BP算法(sgd)和累积BP算法(fullbatch),在西瓜3.0上训练一个单隐层网络,并进行比较。 需要先把字符串转成数字,这里用one-hot。把二分类问题看成多分类问题的特例,然后用softmax。最终模型在训练...
  • 该模型结合了标准误差逆传播算法和累积误差逆传播算法,将大数据集分割成若干个子集,在损失少量准确率的条件下进行并行化处理,并扩展MNIST数据集进行图像识别测试。实验结果表明,该算法对数据规模有较好的适应性...
  • 为了提高纠错码的编译码性能,提出了一种结合重复累积(RA)码级联树(CT)码的累积重复树(ART)码方案,研究了编码结构译码算法,分析了密度进化方法,推导了高斯近似实现算法,讨论了与OFDM调制相结合的无线网络...

空空如也

空空如也

1 2
收藏数 21
精华内容 8
关键字:

标准bp算法和累积bp算法