精华内容
下载资源
问答
  • BP——反向传播算法公式推导及代码

    千次阅读 多人点赞 2019-03-14 23:51:19
    BP——反向传播算法计算过程详解人工神经网络的结构前向传播激活函数反向传播梯度下降具体计算过程 本文主要参考吴恩达和李宏毅的深度学习视频,然后自己做的笔记 反向传播计算部分参考李宏毅的视频讲解,要是有...

    本文主要参考吴恩达和李宏毅的深度学习视频,然后自己做的笔记
    反向传播计算部分参考李宏毅的视频讲解,要是有童鞋也对反向传播这一部分的计算不那么清明,可以考虑选择留下来看看我的笔记,也可以移步李宏毅大神的视频讲解

    人工神经网络的结构

    (注:Markdown敲公式对我来说太困难,后面的公式都用图片的形式展示)
    神经网络的结构包括:输入层(input layer)、隐藏层(hidden layer)、输出层(output layer)。如下图所示:
    神经网络结构
    当然,隐含层可以有无数层,这里我只画了两层。
    输入层输入的数据是训练样本(x1,x2,…,xn,y),训练样本中的x1到xn表示输入的特征值,而y则表示咱们希望输出的预期值。
    隐含层将会进行一系列的计算来缩小训练样本的估计值y’与预期值y之间的误差。
    输出层则会输出训练后得到的估计值y’。

    前向传播

    为了后面的表示方便,我们这里先约定一下每个神经元的表示方法。
    aj[l][i]:第i个样本的第l层上第j个神经元的输入,且有 a[0] = x 。
    z:中间变量
    J:代价函数
    g():激活函数

    前向传播主要完成两个任务:

    1. 计算每一个神经元的激活值a;
    2. 是计算最后的代价函数J(y’, y)(如果我们这里只有一个输入样本的话,那么应该叫做损失函数)。

    即将用到的公式有(这里就以上面给出的人工神经网络结构为例子,即一个样本的表示形式):
    在这里插入图片描述
    我们定义
    前向传播的计算流程:

    1. 输入的准备工作:a[0]、w[1]、b[1]都排排坐,下面准备吃果果啦~
      在这里插入图片描述
    2. 求出a[1]
      在这里插入图片描述
      根据【人工神经网络结构图】可知,咱们的三个输入都连接到了三个神经元上,每个神经元都要有一个输出,因此咱们最后求得的a[1]也是一个3*1的向量。

    咱们将上面的式子扔到神经网络中表示:
    前向传播计算流程
    看到没有,每一个神经元都要进行一次z和a的计算,一直传到输出层,输出层求得的a就是咱们样本的估计值!

    在python中表示求解z、a的式子为:

    z = np.dot(w.T, x)+b
    a = sigmoid(z)    #这里我采用sigmoid()函数作为激活函数,这个函数主要是用来作二分类
    
    1. 损失函数J(y’, y)在python中的表示:

    损失函数:求解单个样本的误差
    代价函数:求解多个样本的误差

    cost = -y * np.log(y') - (1 - y) * np.log(1 - y')   #这里只是单个样本的损失函数,如果咱们有m个样本的话就需要将这m个样本的损失值全部加起来再除以m求得这m个样本的代价函数。
    

    激活函数

    激活函数的作用:加入非线性因素,解决线性不可分问题。(比如说,现在给你一个得用歪七扭八的线来划分两个区域,你用直线肯定是不可能把他俩完美的分开的,但是加入非线性因素以后,你就可以拟合出一条近乎完美的线来划分这两个区域啦~)

    激活函数有很多种,咱在上面使用的是用于二分类的一种常用的激活函数,一般用在输出层。(不同层可以使用不同的激活函数,还有一点很重要的是:激活函数得是可微的!因为咱们在反向传播阶段得对激活函数求导!)

    各种激活函数详情请咨询:千奇百怪的激活函数 来源:wikipedia

    反向传播

    老规矩,先约定一波:
    dw: J对w求偏导
    db: J对b求偏导
    dz: J对z求偏导
    da: J对a求偏导

    步骤:

    1. 求解dw, db
    2. 更新w, b

    方法:梯度下降
    小工具:链式求导

    咱们在计算时一定一定会用到的四个公式:
    反向传播必备公式
    现在看不太明白这几个公式没有关系,咱们先往后走,看看具体是怎么计算的,一会再看这些公式心就明朗啦~ 加油加油,马上就完了!

    梯度下降

    咱们要清楚,方向传播的目的就是为了找到一个最好的w和b,让咱们的损失达到最小,让咱们的结果无限逼近最优解。那么为了让咱们这个值达到最优,咱们就要采用梯度下降的方法来不断优化这个值。当然,学习率的选择也是非常重要的。不然就可能出现两种不太招人待见的情况:1.要训练贼多次才能到达最优解;2.始终到不了最优解。
    梯度下降
    箭头所指的方向就是梯度下降的方向。

    具体计算过程

    step1. 计算隐藏层误差(这里以第一个神经元为例)
    思路:要求解dw[1]和db[1],先要求解出dz[1],要求dz[1],那么先要知道da[1]。因此咱们求解的过程就是da—>dz—>dw,db
    过程如下:
    计算隐藏层误差
    可以看到上面的求解过程就是一个链式求导过程。一层一层的剥开,一层一层的求解。

    step2. 计算输出层误差
    输出层误差的求解过程中间只有一个da[L]这个中间变量。这个就留给大家自己写啦!(其实我最开始的地方都已经给出了)

    step3. 咱们都知道每一层的dw和db是如何得到的了,现在要做的就是更新w和b了!还是用上面更新的那个公式来求解!这里我也不重复写了~

    完结了~
    咱们在实现过程中实际上也是不断迭代求解w和b来训练整个网络结构,使得整个网络的损失达到最小!

    下面是大家最喜欢的部分!不贴代码的博客不是好博客!

    import math
    import random
    import string
    
    random.seed(0)
    
    
    # calculate a random number where:  a <= rand < b
    def rand(a, b):
        return (b - a) * random.random() + a
    
    
    # Make a matrix (we could use NumPy to speed this up)
    def makeMatrix(I, J, fill=0.0):
        m = []
        for i in range(I):
            m.append([fill] * J)
        return m
    
    
    # our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
    def sigmoid(x):
        return math.tanh(x)
    
    
    # derivative of our sigmoid function, in terms of the output (i.e. y)-derivative of tanh
    def dsigmoid(y):
        return 1.0 - y ** 2
    
    
    class CBPNNClass:
        def __init__(self, ni, nh, no):
            # number of input, hidden, and output nodes
            self.ni = ni + 1  # +1 for bias node
            self.nh = nh
            self.no = no
    
            # activations for nodes
            self.ai = [1.0] * self.ni
            self.ah = [1.0] * self.nh
            self.ao = [1.0] * self.no
    
            # create weights
            self.wi = makeMatrix(self.ni, self.nh)
            self.wo = makeMatrix(self.nh, self.no)
            # set them to random vaules
            for i in range(self.ni):
                for j in range(self.nh):
                    self.wi[i][j] = rand(-0.2, 0.2)
            for j in range(self.nh):
                for k in range(self.no):
                    self.wo[j][k] = rand(-2.0, 2.0)
    
            # last change in weights for momentum
            self.ci = makeMatrix(self.ni, self.nh)
            self.co = makeMatrix(self.nh, self.no)
    
        def update(self, inputs):
            if len(inputs) != self.ni - 1:
                raise ValueError('wrong number of inputs')
    
            # input activations
            for i in range(self.ni - 1):
                # self.ai[i] = sigmoid(inputs[i])
                self.ai[i] = inputs[i]
    
            # hidden activations
            for j in range(self.nh):
                sum = 0.0
                for i in range(self.ni):
                    sum = sum + self.ai[i] * self.wi[i][j]
                self.ah[j] = sigmoid(sum)
    
            # output activations
            for k in range(self.no):
                sum = 0.0
                for j in range(self.nh):
                    sum = sum + self.ah[j] * self.wo[j][k]
                self.ao[k] = sigmoid(sum)
    
            return self.ao[:]
    
        def backPropagate(self, targets, N, M):
            if len(targets) != self.no:
                raise ValueError('wrong number of target values')
    
            # calculate error terms for output
            output_deltas = [0.0] * self.no
            for k in range(self.no):
                error = targets[k] - self.ao[k]
                output_deltas[k] = dsigmoid(self.ao[k]) * error
    
            # calculate error terms for hidden
            hidden_deltas = [0.0] * self.nh
            for j in range(self.nh):
                error = 0.0
                for k in range(self.no):
                    error = error + output_deltas[k] * self.wo[j][k]
                hidden_deltas[j] = dsigmoid(self.ah[j]) * error
            # update output weights
            for j in range(self.nh):
                for k in range(self.no):
                    change = output_deltas[k] * self.ah[j]
                    self.wo[j][k] = self.wo[j][k] + N * change + M * self.co[j][k]
                    self.co[j][k] = change
                    # print N*change, M*self.co[j][k]
    
            # update input weights
            for i in range(self.ni):
                for j in range(self.nh):
                    change = hidden_deltas[j] * self.ai[i]
                    self.wi[i][j] = self.wi[i][j] + N * change + M * self.ci[i][j]
                    self.ci[i][j] = change
    
            # calculate error
            error = 0.0
            for k in range(len(targets)):
                error = error + 0.5 * (targets[k] - self.ao[k]) ** 2
            return error
    
        def test(self, patterns):
            for p in patterns:
                print(p[0], '->', self.update(p[0]))
    
        def weights(self):
            print('Input weights:')
            for i in range(self.ni):
                print(self.wi[i])
            print()
            print('Output weights:')
            for j in range(self.nh):
                print(self.wo[j])
    
        def train(self, patterns, iterations=1000, N=0.5, M=0.1):
            # N: learning rate
            # M: momentum factor
            for i in range(iterations):
                error = 0.0
                for p in patterns:
                    inputs = p[0]
                    targets = p[1]
                    self.update(inputs)
                    error = error + self.backPropagate(targets, N, M)
                if i % 100 == 0:
                    print('error %-.5f' % error)
    
    
    def demo():
        # Teach network XOR function
        pat = [
            [[0, 0], [0]],
            [[0, 1], [1]],
            [[1, 0], [1]],
            [[1, 1], [0]]
        ]
        # create a network with two input, two hidden, and one output nodes
        n = CBPNNClass(2, 2, 1)
        # train it with some patterns
        n.train(pat)
        # test it
        n.test(pat)
    
    
    if __name__ == '__main__':
        demo()
    

    代码来源:Andrew Ng的课程!这里并没有使用tensorflow框架,所以很多函数都是自己写的,大家可以将在这个代码上进行改写~

    展开全文
  • CNN反向传播算法公式

    2019-04-10 10:21:00
    反向传播: \begin{align}\notag \delta_j^l = \beta_j^{l+1}(f^\prime(u_j^l) \circ up(\delta_j^{l+1})) \end{align} for j = 1 : numel(net.layers{l}.a) net.layers{l}.d{j} = net.layers{l}.a{j} .* (1...

    网络结构(6c-2s-12c-2s):

    net.jpg

    初始化:

    \begin{align}\notag W \sim U(- \frac{\sqrt{6}}{\sqrt{n_j+n_{j+1}}} , \frac{\sqrt{6}}{\sqrt{n_j+n_{j+1}}}) \end{align}

    \begin{align}\notag Var(W_i) = \frac{1}{n_i} ; Var(W_i) = \frac{1}{n_{i+1}} ; Var(W_i) = \frac{1}{n_i + n_{i+1}} \end{align}

            偏置 $ b $ 统一初始化为 $ 0 $ ,权重 $ W $ 设置为 $ random(-1,1)\sqrt{\frac{6}{fan_{in} + fan_{out}}} \sim U(- \frac{\sqrt{6}}{\sqrt{n_j+n_{j+1}}} , \frac{\sqrt{6}}{\sqrt{n_j+n_{j+1}}}) $ , $ n_j $ 表示神经网络的大小, $ fan_{in} = 输入通道数\times卷积核size $ , $ fan_{out} = 输出通道数\times卷积核size $ 。

        for l = 1 : numel(net.layers)   %  layer
            if strcmp(net.layers{l}.type, 's')
                mapsize = mapsize / net.layers{l}.scale;
                assert(all(floor(mapsize)==mapsize), ['Layer ' num2str(l) ' size must be integer. Actual: ' num2str(mapsize)]);
                for j = 1 : inputmaps
                    net.layers{l}.b{j} = 0;
                end
            end
            if strcmp(net.layers{l}.type, 'c')
                mapsize = mapsize - net.layers{l}.kernelsize + 1;
                fan_out = net.layers{l}.outputmaps * net.layers{l}.kernelsize ^ 2;
                for j = 1 : net.layers{l}.outputmaps  %  output map
                    fan_in = inputmaps * net.layers{l}.kernelsize ^ 2;
                    for i = 1 : inputmaps  %  input map
                        net.layers{l}.k{i}{j} = (rand(net.layers{l}.kernelsize) - 0.5) * 2 * sqrt(6 / (fan_in + fan_out));
                    end
                    net.layers{l}.b{j} = 0;
                end
                inputmaps = net.layers{l}.outputmaps;
            end
        end
        % 'onum' is the number of labels, that's why it is calculated using size(y, 1). If you have 20 labels so the output of the network will be 20 neurons.
        % 'fvnum' is the number of output neurons at the last layer, the layer just before the output layer.
        % 'ffb' is the biases of the output neurons.
        % 'ffW' is the weights between the last layer and the output neurons. Note that the last layer is fully connected to the output layer, that's why the size of the weights is (onum * fvnum)
        fvnum = prod(mapsize) * inputmaps;
        onum = size(y, 1);
    
        net.ffb = zeros(onum, 1);
        net.ffW = (rand(onum, fvnum) - 0.5) * 2 * sqrt(6 / (onum + fvnum));

    前向传播:

    \begin{align}\notag x_j^l = f(\sum_ {i\in M_j} x_i^{l-1} * k_{ij}^l + b_j^l) \end{align}

                %  !!below can probably be handled by insane matrix operations
                for j = 1 : net.layers{l}.outputmaps   %  for each output map
                    %  create temp output map
                    z = zeros(size(net.layers{l - 1}.a{1}) - [net.layers{l}.kernelsize - 1 net.layers{l}.kernelsize - 1 0]);
                    for i = 1 : inputmaps   %  for each input map
                        %  convolve with corresponding kernel and add to temp output map
                        z = z + convn(net.layers{l - 1}.a{i}, net.layers{l}.k{i}{j}, 'valid');
                    end
                    %  add bias, pass through nonlinearity
                    net.layers{l}.a{j} = sigm(z + net.layers{l}.b{j});
                end
                %  set number of input maps to this layers number of outputmaps
                inputmaps = net.layers{l}.outputmaps;

    前向传播:

    \begin{align}\notag x_j^l = f(\beta_j^l down(x_j^{l-1}) + b_j^l) \end{align}

                %  downsample
                for j = 1 : inputmaps
                    z = convn(net.layers{l - 1}.a{j}, ones(net.layers{l}.scale) / (net.layers{l}.scale ^ 2), 'valid');   %  !! replace with variable
                    net.layers{l}.a{j} = z(1 : net.layers{l}.scale : end, 1 : net.layers{l}.scale : end, :);
                end

    前向传播:

        %  concatenate all end layer feature maps into vector
        net.fv = [];
        for j = 1 : numel(net.layers{n}.a)
            sa = size(net.layers{n}.a{j});
            net.fv = [net.fv; reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3))];
        end
        %  feedforward into output perceptrons
        net.o = sigm(net.ffW * net.fv + repmat(net.ffb, 1, size(net.fv, 2)));

    sigmoid函数求导:

    \begin{align}\notag f(x) = \frac{1}{1+e^{-x}} ; f^\prime(x) = \frac{e^{-x}}{(1+e^{-x})^2} = f(x) \cdot [1 - f(x)] \end{align}

    对网络的最后一层输出层,计算输出值和样本值得残差:

    \begin{align}\notag \delta^n = -(y-a^n)\cdot f^\prime(z^n) \end{align}

        %   error
        net.e = net.o - y;
        %%  backprop deltas
        net.od = net.e .* (net.o .* (1 - net.o));   %  output delta

    对于隐层 $ l = n-1,n-2,n-3,...,2 $ ,计算各节点残差:

    \begin{align}\notag \delta^l = ({(W^l)}^T \delta^{l+1}) \cdot f^\prime(z^l) \end{align}

        %  concatenate all end layer feature maps into vector
        net.fv = [];
        for j = 1 : numel(net.layers{n}.a)
            sa = size(net.layers{n}.a{j});
            net.fv = [net.fv; reshape(net.layers{n}.a{j}, sa(1) * sa(2), sa(3))];
        end
        net.fvd = (net.ffW' * net.od);              %  feature vector delta
        if strcmp(net.layers{n}.type, 'c')         %  only conv layers has sigm function
            net.fvd = net.fvd .* (net.fv .* (1 - net.fv));
        end

    反向传播:

    \begin{align}\notag \delta_j^l = f^\prime(u_j^l)\circ conv2(\delta_j^{l+1},rot180(k_j^{l+1}),'full') \end{align}

                for i = 1 : numel(net.layers{l}.a)
                    z = zeros(size(net.layers{l}.a{1}));
                    for j = 1 : numel(net.layers{l + 1}.a)
                         z = z + convn(net.layers{l + 1}.d{j}, rot180(net.layers{l + 1}.k{i}{j}), 'full');
                    end
                    net.layers{l}.d{i} = z;
                end

    反向传播:

    \begin{align}\notag \delta_j^l = \beta_j^{l+1}(f^\prime(u_j^l) \circ up(\delta_j^{l+1})) \end{align}

                for j = 1 : numel(net.layers{l}.a)
                    net.layers{l}.d{j} = net.layers{l}.a{j} .* (1 - net.layers{l}.a{j}) .* (expand(net.layers{l + 1}.d{j}, [net.layers{l + 1}.scale net.layers{l + 1}.scale 1]) / net.layers{l + 1}.scale ^ 2);
                end

    计算最终需要的偏导数值:

    \begin{align}\notag \nabla_{W^l}J(W,b;x,y) = \delta^{l+1}(a^l)^T \end{align}

    \begin{align}\notag \nabla_{b^l}J(W,b;x,y) = \delta^{l+1} \end{align}

    \begin{align}\notag \nabla_{W^l}J(W,b) = [\frac{1}{m}\sum_{i=1}^m\nabla_{W^l}J(W,b;x,y)]+\lambda W_{ij}^l \end{align}

    \begin{align}\notag \nabla_{b^l}J(W,b) = \frac{1}{m}\sum_{i=1}^m\nabla_{b^l}J(W,b;x,y) \end{align}

    \begin{align}\notag \frac{\partial E}{\partial k_{ij}^l} = rot180(conv2(x_i^{l-1},rot180(\delta_j^l),'valid')) \end{align}

    \begin{align}\notag \frac{\partial E}{\partial b_j} = \sum_{u,v}(\delta_j^l)_{uv} \end{align}

        for l = 2 : n
            if strcmp(net.layers{l}.type, 'c')
                for j = 1 : numel(net.layers{l}.a)
                    for i = 1 : numel(net.layers{l - 1}.a)
                        net.layers{l}.dk{i}{j} = convn(flipall(net.layers{l - 1}.a{i}), net.layers{l}.d{j}, 'valid') / size(net.layers{l}.d{j}, 3);
                    end
                    net.layers{l}.db{j} = sum(net.layers{l}.d{j}(:)) / size(net.layers{l}.d{j}, 3);
                end
            end
        end
        net.dffW = net.od * (net.fv)' / size(net.od, 2);
        net.dffb = mean(net.od, 2);

    转载于:https://www.cnblogs.com/ratels/p/10681696.html

    展开全文
  • 经典反向传播算法公式详细推导

    千次阅读 2016-07-09 18:26:20
    最近学习CNN时,对反向传播算法模棱两可,公式经常是提起笔就忘记,而且网上的推导看着就烦。于是趁着现在明白了,赶紧写篇博文,留作日后参考。
    展开全文
  • 学神经网络,那么它的训练利器:反向传播算法,不能不会哦是不是看到这样的公式就头晕脑胀?下面拆解开来,其实就是一个很简单的链索反应呀: 链式求导法则推荐阅读 历史技术博文链接汇总 也许可以找到你想要的

    每次推导公式时,感觉整个世界都安静了下来!

    学神经网络,那么它的训练利器:反向传播算法,不能不会哦

    是不是看到这样的公式就头晕脑胀?

    下面拆解开来,其实就是一个很简单的链索反应呀: 链式求导法则

    page 1

    page 2

    page 3


    推荐阅读
    历史技术博文链接汇总
    也许可以找到你想要的

    展开全文
  • 反向传播算法公式的推导

    千次阅读 2016-12-26 13:19:07
    一、参数说明 W(l)ij:表示第l−1层的第j个特征到第l层第...二、公式定义 激活函数(这里采用sigmoid函数来做分类):f(z)=11+e−zl层神经元的状态值:z(l)=w(l)a(l−1)+b(l),表示一个神经元所获得的输入信号的加权和
  • 反向传播算法 基础知识 我们在计算神经网络预测结果时采用了正向传播方法,从第一层开始正向一层一层进行计算算,直到最后一层的hθ(x)h_\theta (x)hθ​(x)。在不作正则化处理的情况下,逻辑回归中的代价函数如下所...
  • 卷积神经网络(CNN)反向传播算法公式详细推导

    万次阅读 多人点赞 2016-07-18 20:56:15
    在看本篇博文之前,你需要对卷积神经网络有一定的理解,并且能够自主推导出经典BP神经网络反向传播的相关公式
  • 3: 反向传播公式的推导 注意: 下述公式中所有加粗符号表示向量,未加粗符号表示标量。 (1) 公式1:损失函数在输出层神经元上的误差。(此时符号表示网络的输出层) 对于层上的...
  • 【正向和反向传播】 【梯度下降i法】 【逻辑回归代价函数】 【实现神经网络的步骤】 【浅层神经网络例子】 import numpy as np def sigmoid(x): """ Compute the sigmoid of x ...
  • 神经网络算法推演——神经网络中反向传播算法代码实现 1. 算法背景 如下图来自charlotte77的博文 看完charlotte77大神的博文,终于弄明白了神经网络中的前向传播及反向传播算法,自己也搜索各种资料,文档,...
  • 这几天在学习深度学习方面的知识,学习...原博知乎链接:MrLi:神经网络BP反向传播算法推导​zhuanlan.zhihu.com以及觉得很好懂得反向传播的博客链接:EdisonGzq:深度学习---反向传播的具体案例​zhuanlan.zhihu.c...
  • 介绍反向传播算法(Back Propagation)的文章有很多,但讲得通俗易懂的很少,有的只给出公式推导,很难理解,有的虽然给出了例子,但介绍得过于复杂,看完之后在脑海里很难形成一个清晰且具象的认识。本文将通过一个...
  • 反向传播算法及其梯度扩散前言最近开始认真学习了下反向传播算法和梯度传递的问题,其本质是导数的链式法则的应用,由此可以分析出为什么sigmoid激活函数不适合用于做多层网络的激活函数,可以考虑联系我的另一篇...
  • 34)100天搞定机器学习|Day35 深度学习之神经网络的结构100天搞定机器学习|Day36深度学习之梯度下降算法本篇为100天搞定机器学习之第37天,亦为3Blue1Brown《深度学习之反向传播算法》学习笔记。 上集提到我们要找到...
  • 反向传播算法(过程及公式推导)

    万次阅读 多人点赞 2016-04-01 21:19:56
    反向传播算法(Backpropagation)是目前用来训练人工神经网络(Artificial Neural Network,ANN)的最常用且最有效的算法。
  • 点击上方“机器学习算法与Python实战”,选择“置顶”公众号重磅干货,第一时间送达往期回顾100天搞定机器学习|(Day1-36)100天搞定机器学习|Day37无公式理解反向传播算法之精髓上集我们学习了反向传播算法的原理,...
  • 反向传播反向传播算法参考http://neuralnetworksanddeeplearning.com/chap2.htmldef conv_forward(X, W, b, stride=1, padding=1): cache = W, b, stride, padding n_filters, d_filter, h_filte...
  • 反向传播算法公式推导

    千次阅读 2018-05-24 15:45:00
    反向传播(Back Propagation, BP)算法是使用梯度下降法相关的算法来优化一个神经网络时计算每一层梯度的方法,主要使用了多元函数的链式法则。 公式推导 1、模型 不失一般性,我们考虑以下4层结构的神经网络...
  • 其中在实现过程中,将会用代码的形式呈现梯度消失的现象,本文中的符号请参考我的前文《反向传播算法公式推导》,代码将由github托管,有帮助的朋友欢迎star。 如有谬误,请联系指正。转载请注明出处。 联系方式:...
  • 选择加"星标"或“置顶”重磅干货,第一时间送达作者:南柯一梦宁沉沦https://zhuanlan.zhihu.com/p/61863634本文已授权,未经允许,不得二次转载本文以神经网络中最简单的全连接神经网络为例介绍反向传播算法的理论...
  • 本文试图探讨反向传播算法,但只关注思想和原理,寻求一个直观感性的认识。所以,文中所举的例子、使用的公式都力图简单。简,就意味着会损失细节、不够全面。如果对反向传播算法已经有所涉及,希望全面、深入了解的...
  • 前向传播结构图 在推导反向传播之前,首先我们需要了解深度神经网络的模型图,我简单的画个模型图:这是模型的最后两层,L代表输出层,假设有两个输出 , ,拼成一个输出列向量 L-1层有三个节点,有三个输出 , , ...
  • 如果要想求误差E对w1的导数,误差E对w1的求导路径不止一条,这会稍微复杂一点,但换汤不换药,计算过程如下所示: 至此,“反向传播算法”及公式推导的过程总算是讲完了啦!个人感觉,尤其是第二组图,还算是蛮通俗...
  • 不妨采用最常见的均方差来度量损失。 , 首先求输出层W,b的梯度 提取公共部分,令 接着求第l层W,b的梯度 有了每一层W,b的梯度值,就可以进行反向更新每一层的W,b。  ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 599
精华内容 239
关键字:

反向传播算法公式