精华内容
下载资源
问答
  • 针对现有曲面采样点云法向传播方法难以快速处理大规模数据的问题,提出了一种在多层黎曼图中统一点云法向的方法。该方法对点云进行子集递归划分得到核心点集,以核心点集的曲面变分程度控制递归次数,为点云构造树状...
  • 针对近邻传播聚类算法偏向参数难选定、生成的簇数目偏等问题,提出一种概率无图模型的近邻传播聚类算法.首先为样本数据构建概率无图模型,利用极大团和势函数计算无图中数据样本的概率密度,将此概率密度作为一...
  • 向传播和反向传播

    千次阅读 2019-02-15 23:35:28
    向传播和反向传播1. 前向传播2. 反向传播 例程:生产一批零件,将体积X1和重量X2为特征输入NN,通过NN后输出一个数值 1. 前向传播向传播过程 用Tensorflow表示前向传播 X为1*2的...

    例程:生产一批零件,将体积X1和重量X2为特征输入NN,通过NN后输出一个数值

    1. 前向传播

    前向传播就是搭建模型的计算过程,让模型具有推理能力,可以针对一组输入给出相应的输出

    1.1 前向传播过程

    在这里插入图片描述

    • 第一层
    X W ( 1 ) W^(1^) W(1)a
    x 表示输入,是一个 1 行 2 列矩阵,表示1次输入1组特征(包含了体积和重量两个元素)对于第一层的 w 前面有两个节点,后面有三个节点 W ( 1 ) W^(1^) W(1) 应该是个2行3列矩阵a 为第一层网络,a 是一个1行3列矩阵
    • 第二层
    W ( 2 ) W^(2^) W(2)
    参数要满足前面三个节点,后面一个节点,所以 是3行1列矩阵

    注:神经网络共有几层(或当前是第几层网络)都是指的计算层,输入不是计算层,所以 a 为第一层网络

    1.2 用Tensorflow表示前向传播

    -

    • 变量初始化、计算图节点运算都要用会话(with 结构)实现
      with tf.Session() as sess:
      sess.run()

      • 变量初始化:在 sess.run 函数中用 tf.global_variables_initializer()汇总所有待优化变量。
        init_op = tf.global_variables_initializer()
        sess.run(init_op)
      • 计算图节点运算:在 sess.run 函数中写入待运算的节点
        sess.run(y)
      • 用 tf.placeholder 占位,在 sess.run 函数中用 feed_dict 喂数据
        喂一组数据:
        x = tf.placeholder(tf.float32, shape=(1, 2))
        sess.run(y, feed_dict={x: [[0.5,0.6]]})
        喂多组数据:
        x = tf.placeholder(tf.float32, shape=(None, 2))
        sess.run(y, feed_dict={x: [[0.1,0.2],[0.2,0.3],[0.3,0.4],[0.4,0.5]]})

    1.3 实现神经网络前向传播过程,网络自动推理出输出 y 的值

    • 例1:用 placeholder 实现输入定义(sess.run 中喂入一组数据)的情况
      第一组喂体积 0.7、重量 0.5
    #coding:utf-8
    import tensorflow as tf
    
    #定义输入和参数
    x=tf.placeholder(tf.float32,shape=(1,2))
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    
    #定义前向传播过程
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    
    #用会话计算结果
    with tf.Session() as sess:
    	init_op=tf.global_variables_initializer()
    	sess.run(init_op)
    	print (sess.run(y,feed_dict={x:[[0.7,0.5]]}))
    
    • 例2:用 placeholder 实现输入定义(sess.run 中喂入多组数据)的情况
      第一组喂体积 0.7、重量 0.5,第二组喂体积 0.2、重量 0.3,第三组喂体积0.3、重量 0.4,第四组喂体积 0.4、重量 0.5.
    #coding:utf-8
    import tensorflow as tf
    #定义输入和参数
    x=tf.placeholder(tf.float32,shape=(None,2))
    w1=tf.Variable(tf.random_normal([2,3],stddev=1,seed=1))
    w2=tf.Variable(tf.random_normal([3,1],stddev=1,seed=1))
    #定义前向传播过程
    a=tf.matmul(x,w1)
    y=tf.matmul(a,w2)
    #用会话计算结果
    with tf.Session() as sess:
    	init_op=tf.global_variables_initializer()
    	sess.run(init_op)
    	print(sess.run(y,feed_dict={x:[[0.7,0.5],[0.2,0.3],[0.3,0.4],[0.4,0.5]]}))
    

    2. 反向传播

    反向传播:就是训练模型参数,在所有参数上用梯度下降,使 NN 模型在训练数据上的损失函数最小

    2.1 损失函数

    损失函数(loss):计算得到的预测值 y 与已知答案 y_的差距

    • 损失函数计算方法:有很多方法,均方误差 MSE 是比较常用的方法之一
    均方误差 MSE解释
    定义求前向传播计算结果与已知答案之差的平方再求平均
    公式图1
    tensorflow 函数表示loss_mse = tf.reduce_mean(tf.square(y_ - y))

    2.2 反向传播训练方法:以减小 loss 值为优化目标

    反向传播训练方法梯度下降momentum 优化器adam 优化器、、、
    用 tensorflow 函数表示train_step=tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)train_step=tf.train.MomentumOptimizer(learning_rate, momentum).minimize(loss)train_step=tf.train.AdamOptimizer(learning_rate).minimize(loss)
    区别使用随机梯度下降算法,使参数沿着梯度的反方向,即总损失减小的方向移动,实现更新参数更新参数时,利用了超参数利用自适应学习率的优化算法,Adam 算法和随机梯度下降算法不同。随机梯度下降算法保持单一的学习率更新所有的参数,学习率在训练过程中并不会改变。而 Adam 算法通过计算梯度的一阶矩估计和二阶矩估计而为不同的参数设计独立的自适应性学习率
    参数更新的公式在这里插入图片描述 损失函数:J(?) 参数:?,学习率:?在这里插入图片描述 ?为学习率,超参数为?,?为参数,损失函数的梯度:?(??−1)
    • 学习率
      • 决定每次参数更新的幅度
      • 优化器中都需要一个叫做学习率的参数,使用时,如果学习率选择过大会出现震荡不收敛的情况,如果学习率选择过小,会出现收敛速度慢的状况。我们可以选个比较小的值填入,比如 0.01、0.001
    展开全文
  • 神经网络的前向传播和反向传播

    千次阅读 2020-05-25 00:50:23
    向传播过程 在讨论反向传播之前,我们讨论一下前向传播,即根据输入X来计算输出Y。输入X用矩阵表示,我们看一下如何基于矩阵X来计算网络的输出Y。 我们使用 表示从层的第 个神经元到层的个神经元的链接上的权重...

    本博客是对Michael Nielsen所著的《Neural Network and Deep Learning》第2章内容的解读,有兴趣的朋友可以直接阅读原文http://neuralnetworksanddeeplearning.com/chap2.html

    前向传播过程

    在讨论反向传播之前,我们讨论一下前向传播,即根据输入X来计算输出Y。输入X用矩阵表示,我们看一下如何基于矩阵X来计算网络的输出Y。

    我们使用 表示从 ( - 1) 层的第 k 个神经元到  层的第 j 个神经元的链接上的权重。例如,下图给出了网络中第二层的第四个神经元到第三层的第二个神经元的链接上的权重:

    我们使用表示在  层第 j 个神经元的偏置,使用表示  层第 j 个神经元的激活值(激活函数的输出)。

    那么,第  层的第 j 个神经元的激活值可以表示为:

                                                             (1)

    其中,为激活函数。

    对每一层 ,定义一个权重矩阵,权重矩阵 的元素正是连接到  层神经元的权重,矩阵中第 j 行第 k 列的元素是 。类似的,对每一层,定义一个偏置向量,向量的每个元素为,每个元素对应于  层每个神经元的偏置。最后,我们定义激活向量,其元素是那些激活值

    那么,公式(1)就可以表示为如下的向量形式:

                                                              (2)

    这个表达式给出了一种更加全局的思考每层的激活值和前一层激活值的关联方式:用权重矩阵作用在激活值上,然后加上一个偏置向量,最后作用 σ 函数,则得到每层的激活值。

    为了方便表示,记,表示  层神经元的权重输入,则公式(2)变为

     

    输入X,然后根据公式(2)一层层计算网络的激活值,最终得到网络的输出Y。

     

    反向传播过程

    反向传播的两个假设

    反向传播的目标是计算代价函数C关于w和b的偏导数∂C/∂w 和 ∂C/∂b。为了使反向传播工作,我们需要对代价函数做两个假设。在给出这两个假设之前,我们先看一个具体的代价函数,即如下的二次代价函数:

                                         (3)

    其中x为训练样本,n是训练样本的总数;y = y(x) 是期望的输出,即样本的真实值;L表示网络的层数;为网络的输出向量。

    假设1:代价函数可以表示为单个样本的代价函数的均值,即:

                                                  (4)

    其中,表示训练样本x的代价函数。以二次代价函数为例,

    需要做这个假设的原因是,反向传播实际上是对一个独立的训练样本计算了 ∂Cx/∂w 和 ∂Cx/∂b。在这个假设下,我们可以通过计算所有样本的平均来得到总体的∂C/∂w 和 ∂C/∂b。

    假设2:代价函数可以表示为神经网络输出的函数:

    比如,单个样本x的平方代价函数可以写为:

                          (5)

    这是输出的激活值的函数。当然,这个代价函数同样还依赖于目标输出 y。不过,输入的训练样本 x 是固定的,所以输出 y 同样是一个固定的参数。尤其是它并不会随权重和偏置而改变,也就是说,这不是神经网络学习的对象。所以,将C看成输出激活值的函数才是合理的,而 y 仅仅是帮助定义函数的参数而已。

    反向传播的四个基本方程

    反向传播指的是权重w和偏置b的改变如何改变代价函数C。其含义其实就是计算偏导数。在讨论基本方程之前,我们引入一个中间变量,表示第  层第 j 个单元的误差。关于误差,《Neural Networks and Deep Learning》给出了一个很形象的例子:

    如上图所示,假设网络中有个小调皮鬼,他在第  层第 j 个神经元上。当输入进来时,调皮鬼对神经元的操作进行扰乱,导致神经元的权重输入增加很小的变化,使得神经元输出由变为。这个变化向网络后面的层进行传播,最终导致整个代价产生的改变为 。

    现在,这个调皮鬼改过自新了,他想帮助我们尽可能减小代价,他试着找到可以让代价更小的。假设一开始是个很大的正值或负值,那么,调皮鬼可以通过选择一个和方向相反的使代价函数更小。随着迭代的进行,会逐渐趋近于0,那么对代价函数的改进就微乎其微了。这时,对调皮鬼来说,他已经找到最优解了(局部最优)。这启发我们可以用来衡量神经元的误差。即, 层第 j 个神经元的误差为:

                                               (6)

    我们用来表示  层的误差向量。

     

    下面我们看看反向传播的四个基本方程。

    1. 输出层的误差方程,

    由于,应用链式法则,加入输出激活值的偏导数,则之前偏导数变为:

                                  (7)

    求和是在输出层的所有神经元k上进行的。第 k 个神经元的输出激活值只依赖于当 k = j 时第 j 个神经元的输入权重,所以当  k ≠ j 时 项为0。则上一个方程可以简化为:

                                              (8)

    由于,上式中右边第二项可以写为,则方程变为:

                                                 (BP1)

    右式第一项∂C/表示代价随着第 j 个输出激活值的变化而变化的速度。右式第二项刻画了在处激活函数 σ 变化的速度。

    (BP1)改写为矩阵形式,为:

                           (BP1a)

    其中,是一个向量,其元素为偏导数∂C/表示hadamard乘积运算。

     

    注:hadamard乘积即按元素乘法,比如:

     

    2. 误差传递方程:

    即,根据下一层的误差来表示误差

    根据公式(6),,应用链式法则:

                            (9)

    注意:

                       

    做微分,则得到:

    把它代入公式(9),则得到:

    改为分量形式,则为:

                                        (BP2

    这个方程说明我们可以通过第 l + 1 层的误差计算第 l 层的误差。结合(BP1)和(BP2),我们可以计算任何层的误差。首先,使用方程(BP1)计算,然后用方程(BP2)来计算,然后再次用方程(BP2)来计算,如此一步一步的反向传播完整个网络。

     

    3. 代价函数对bias的改变率

                                                    (BP3)

    由于,所以

     

    4. 代价函数对权重的改变率

                                                       (BP4)

    可以简写为:

    其中,是输入给权重w的的神经元的激活值,是输出自权重 w 的神经元的误差。

    不难看出,当上一层激活值很小的时候,即 ≈ 0,无论误差多大,梯度 ∂C/∂w 也会很小,表示在梯度下降的时候,这个权重不会改变太多。也就是说,来自低激活值神经元的权重学习会非常缓慢。

    另外,从输出层看,先看看(BP1  )中的项。若σ为sigmoid函数,在靠近0和1的时候,σ函数变得非常平。这时≈ 0。所以,如果输出神经元处于低激活值(≈ 0)或高激活值(≈ 1)时,最终层的权重/bias变化也会比较小,学习变慢。此时,我们常常称输出神经元已经饱和了。

    总结来说,如果输入神经元激活值很低,或者输出神经元已经饱和了(过高或过低的激活值),权重和bias会学习的非常慢。

    反向传播算法

    有了以上反向传播方程,反向传播算法描述如下:

    1. 输出 x

    2. 前向传播:对l = 2, 3, ..., L,计算

    3. 计算输出层误差:计算向量

    4. 反向传播误差:对每个 l = L - 1, L - 2, ..., 2,计算

    5. 输出:计算代价函数梯度

    得到梯度后,就可以使用梯度下降法对参数进行一轮轮更新了,直到最后模型收敛。

     

    为什么说反向传播算法高效

    在哪种层面上,反向传播是快速的算法?为了回答这个问题,首先考虑另一个计算梯度的方法。把代价看做权重的函数 C = C(w)。你给这些权重,...进行编号,期望计算某些权重的偏导数。 而一种近似的方法就是下面这种:

                                      (10)

    其中 ε > 0 是一个很小的正数,而  是在第 j 个方向上的单位向量。换句话说,我们可以通过计算两个接近相同的 的代价 C 来估计 。同样方法也可以用来计算 ∂C/∂b。

    不过,这个方法非常低效。假如我们的网络中有100万个权重。要计算,我们需要从头到尾进行一次完整的前向传播才能得到的值。要计算100万个权重的偏导就需要前向传播100万次。我们同样需要计算 C(w),需要一次网络传播。总共需要 100百万+1 次网络传播。

    再反观反向传播算法,根据方程(BP4),我们只需要知道就能计算出。激活值在一次前向传播后就能全部得到,然后利用(BP1)和(BP2)就可以计算出。反向传播和前向传播计算量相当,所以,总共需要2次前向传播的计算量就能计算出所有的。对比用微分定义求偏导的100百万次,计算量大大减少。

     

    展开全文
  • TensorFlow2 手把手教你实现前向传播

    千次阅读 多人点赞 2021-06-09 06:00:33
    TensorFlow2 手把手教你实现前向传播.

    概述

    前向传播 (Forward propagation) 是将上一层输出作为下一层的输入, 并计算下一层的输出, 一直到运算到输出层为止.

    在这里插入图片描述

    会用到的函数

    在这里插入图片描述

    张量最小值

    ```reduce_min``函数可以帮助我们计算一个张量各个维度上元素的最小值.

    格式:

    tf.math.reduce_min(
        input_tensor, axis=None, keepdims=False, name=None
    )
    

    参数:

    • input_tensor: 传入的张量
    • axis: 维度, 默认计算所有维度
    • keepdims: 如果为真保留维度, 默认为 False
    • name: 数据名称

    张量最大值

    ```reduce_max``函数可以帮助我们计算一个张量各个维度上元素的最大值.

    格式:

    tf.math.reduce_max(
        input_tensor, axis=None, keepdims=False, name=None
    )
    

    参数:

    • input_tensor: 传入的张量
    • axis: 维度, 默认计算所有维度
    • keepdims: 如果为真保留维度, 默认为 False
    • name: 数据名称

    数据集分批

    from_tensor_slices可以帮助我们切分传入 Tensor 的第一个维度. 得到的每个切片都是一个样本数据.

    在这里插入图片描述

    格式:

    @staticmethod
    from_tensor_slices(
        tensors
    )
    

    迭代

    我们可以调用iter函数来生成迭代器.

    格式:

    iter(object[, sentinel])
    

    参数:
    -object: 支持迭代的集合对象

    • sentinel: 如果传递了第二个参数, 则参数 object 必须是一个可调用的对象 (如, 函数). 此时, iter 创建了一个迭代器对象, 每次调用这个迭代器对象的__next__()方法时, 都会调用 object

    例子:

    list = [1, 2, 3]
    i = iter(list)
    print(next(i))
    print(next(i))
    print(next(i))
    

    输出结果:

    1
    2
    3
    

    截断正态分布

    truncated_normal可以帮助我们生成一个截断的正态分布. 生成的正态分布值会在两倍的标准差的范围之内.

    在这里插入图片描述
    格式:

    tf.random.truncated_normal(
        shape, mean=0.0, stddev=1.0, dtype=tf.dtypes.float32, seed=None, name=None
    )
    

    参数:

    • shape: 张量的形状
    • mean: 正态分布的均值, 默认 0.0
    • stddev: 正态分布的标准差, 默认为 1.0
    • dtype: 数据类型, 默认为 float32
    • seed: 随机数种子
    • name: 数据名称

    relu 激活函数

    激活函数有 sigmoid, maxout, relu 等等函数. 通过激活函数我们可以使得各个层之间达成非线性关系.
    在这里插入图片描述
    激活函数可以帮助我们提高模型健壮性, 提高非线性表达能力, 缓解梯度消失问题.

    one_hot

    tf.one_hot函数是讲 input 准换为 one_hot 类型数据输出. 相当于将多个数值联合放在一起作为多个相同类型的向量.

    格式:

    tf.one_hot(
        indices, depth, on_value=None, off_value=None, axis=None, dtype=None, name=None
    )
    

    参数:

    • indices: 索引的张量
    • depth: 指定独热编码维度的标量
    • on_value: 索引 indices[j] = i 位置处填充的标量,默认为 1
    • off_value: 索引 indices[j] != i 所有位置处填充的标量, 默认为 0
    • axis: 填充的轴, 默认为 -1 (最里面的新轴)
    • dtype: 输出张量的数据格式
    • name:数据名称

    assign_sub

    assign_sub可以帮助我们实现张量自减.

    格式:

    tf.compat.v1.assign_sub(
        ref, value, use_locking=None, name=None
    )
    

    参数:

    • ref: 多重张量
    • value: 张量
    • use_locking: 锁
    • name: 数据名称

    准备工作

    在这里插入图片描述

    import tensorflow as tf
    
    # 定义超参数
    batch_size = 256  # 一次训练的样本数目
    learning_rate = 0.001  # 学习率
    iteration_num = 20  # 迭代次数
    
    # 读取mnist数据集
    (x, y), _ = tf.keras.datasets.mnist.load_data()  # 读取训练集的特征值和目标值
    print(x[:5])  # 调试输出前5个图
    print(y[:5])  # 调试输出前5个目标值数字
    print(x.shape)  # (60000, 28, 28) 单通道
    print(y.shape)  # (60000,)
    
    # 转换成常量tensor
    x = tf.convert_to_tensor(x, dtype=tf.float32) / 255  # 转换为0~1的形式
    y = tf.convert_to_tensor(y, dtype=tf.int32)  # 转换为整数形式
    
    # 调试输出范围
    print(tf.reduce_min(x), tf.reduce_max(x))  # 0~1
    print(tf.reduce_min(y), tf.reduce_max(y))  # 0~9
    
    # 分割数据集
    train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(batch_size)  # 256为一个batch
    train_iter = iter(train_db)  # 生成迭代对象
    
    # 定义权重和bias [256, 784] => [256, 256] => [256, 128] => [128, 10]
    w1 = tf.Variable(tf.random.truncated_normal([784, 256], stddev=0.1))  # 标准差为0.1的截断正态分布
    b1 = tf.Variable(tf.zeros([256]))  # 初始化为0
    
    w2 = tf.Variable(tf.random.truncated_normal([256, 128], stddev=0.1))  # 标准差为0.1的截断正态分布
    b2 = tf.Variable(tf.zeros([128]))  # 初始化为0
    
    w3 = tf.Variable(tf.random.truncated_normal([128, 10], stddev=0.1))  # 标准差为0.1的截断正态分布
    b3 = tf.Variable(tf.zeros([10]))  # 初始化为0
    

    输出结果:

    [[[0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      ...
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]]
    
     [[0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      ...
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]]
    
     [[0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      ...
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]]
    
     [[0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      ...
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]]
    
     [[0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      ...
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]
      [0 0 0 ... 0 0 0]]]
    [5 0 4 1 9]
    (60000, 28, 28)
    (60000,)
    tf.Tensor(0.0, shape=(), dtype=float32) tf.Tensor(1.0, shape=(), dtype=float32)
    tf.Tensor(0, shape=(), dtype=int32) tf.Tensor(9, shape=(), dtype=int32)
    

    train 函数

    def train(epoch):  # 训练
        for step, (x, y) in enumerate(train_db):  # 每一批样本遍历
            # 把x平铺 [256, 28, 28] => [256, 784]
            x = tf.reshape(x, [-1, 784])
    
            with tf.GradientTape() as tape:  # 自动求解
                # 第一个隐层 [256, 784] => [256, 256]
                # [256, 784]@[784, 256] + [256] => [256, 256] + [256] => [256, 256] + [256, 256] (广播机制)
                h1 = x @ w1 + tf.broadcast_to(b1, [x.shape[0], 256])
                h1 = tf.nn.relu(h1)  # relu激活
    
                # 第二个隐层 [256, 256] => [256, 128]
                h2 = h1 @ w2 + b2
                h2 = tf.nn.relu(h2)  # relu激活
    
                # 输出层 [256, 128] => [128, 10]
                out = h2 @ w3 + b3
    
                # 计算损失MSE(Mean Square Error)
                y_onehot = tf.one_hot(y, depth=10)  # 转换成one_hot编码
                loss = tf.square(y_onehot - out)  # 计算总误差
                loss = tf.reduce_mean(loss)  # 计算平均误差MSE
    
    
            # 计算梯度
            grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
    
            # 更新权重
            w1.assign_sub(learning_rate * grads[0])  # 自减梯度*学习率
            b1.assign_sub(learning_rate * grads[1])  # 自减梯度*学习率
            w2.assign_sub(learning_rate * grads[2])  # 自减梯度*学习率
            b2.assign_sub(learning_rate * grads[3])  # 自减梯度*学习率
            w3.assign_sub(learning_rate * grads[4])  # 自减梯度*学习率
            b3.assign_sub(learning_rate * grads[5])  # 自减梯度*学习率
    
            if step % 100 == 0:  # 每运行100个批次, 输出一次
                print("epoch:", epoch, "step:", step, "loss:", float(loss))
    

    run 函数

    def run():
        for i in range(iteration_num):  # 迭代20次
            train(i)
    

    完整代码

    import tensorflow as tf
    
    # 定义超参数
    batch_size = 256  # 一次训练的样本数目
    learning_rate = 0.001  # 学习率
    iteration_num = 20  # 迭代次数
    
    # 读取mnist数据集
    (x, y), _ = tf.keras.datasets.mnist.load_data()  # 读取训练集的特征值和目标值
    print(x[:5])  # 调试输出前5个图
    print(y[:5])  # 调试输出前5个目标值数字
    print(x.shape)  # (60000, 28, 28) 单通道
    print(y.shape)  # (60000,)
    
    # 转换成常量tensor
    x = tf.convert_to_tensor(x, dtype=tf.float32) / 255  # 转换为0~1的形式
    y = tf.convert_to_tensor(y, dtype=tf.int32)  # 转换为整数形式
    
    # 调试输出范围
    print(tf.reduce_min(x), tf.reduce_max(x))  # 0~1
    print(tf.reduce_min(y), tf.reduce_max(y))  # 0~9
    
    # 分割数据集
    train_db = tf.data.Dataset.from_tensor_slices((x, y)).batch(batch_size)  # 256为一个batch
    train_iter = iter(train_db)  # 生成迭代对象
    
    # 定义权重和bias [256, 784] => [256, 256] => [256, 128] => [128, 10]
    w1 = tf.Variable(tf.random.truncated_normal([784, 256], stddev=0.1))  # 标准差为0.1的截断正态分布
    b1 = tf.Variable(tf.zeros([256]))  # 初始化为0
    
    w2 = tf.Variable(tf.random.truncated_normal([256, 128], stddev=0.1))  # 标准差为0.1的截断正态分布
    b2 = tf.Variable(tf.zeros([128]))  # 初始化为0
    
    w3 = tf.Variable(tf.random.truncated_normal([128, 10], stddev=0.1))  # 标准差为0.1的截断正态分布
    b3 = tf.Variable(tf.zeros([10]))  # 初始化为0
    
    
    def train(epoch):  # 训练
        for step, (x, y) in enumerate(train_db):  # 每一批样本遍历
            # 把x平铺 [256, 28, 28] => [256, 784]
            x = tf.reshape(x, [-1, 784])
    
            with tf.GradientTape() as tape:  # 自动求解
                # 第一个隐层 [256, 784] => [256, 256]
                # [256, 784]@[784, 256] + [256] => [256, 256] + [256] => [256, 256] + [256, 256] (广播机制)
                h1 = x @ w1 + tf.broadcast_to(b1, [x.shape[0], 256])
                h1 = tf.nn.relu(h1)  # relu激活
    
                # 第二个隐层 [256, 256] => [256, 128]
                h2 = h1 @ w2 + b2
                h2 = tf.nn.relu(h2)  # relu激活
    
                # 输出层 [256, 128] => [128, 10]
                out = h2 @ w3 + b3
    
                # 计算损失MSE(Mean Square Error)
                y_onehot = tf.one_hot(y, depth=10)  # 转换成one_hot编码
                loss = tf.square(y_onehot - out)  # 计算总误差
                loss = tf.reduce_mean(loss)  # 计算平均误差MSE
    
    
            # 计算梯度
            grads = tape.gradient(loss, [w1, b1, w2, b2, w3, b3])
    
            # 更新权重
            w1.assign_sub(learning_rate * grads[0])  # 自减梯度*学习率
            b1.assign_sub(learning_rate * grads[1])  # 自减梯度*学习率
            w2.assign_sub(learning_rate * grads[2])  # 自减梯度*学习率
            b2.assign_sub(learning_rate * grads[3])  # 自减梯度*学习率
            w3.assign_sub(learning_rate * grads[4])  # 自减梯度*学习率
            b3.assign_sub(learning_rate * grads[5])  # 自减梯度*学习率
    
            if step % 100 == 0:  # 每运行100个批次, 输出一次
                print("epoch:", epoch, "step:", step, "loss:", float(loss))
    
    
    def run():
        for i in range(iteration_num):  # 迭代20次
            train(i)
    
    
    if __name__ == "__main__":
        run()
    

    输出结果:

    epoch: 0 step: 0 loss: 0.5439826250076294
    epoch: 0 step: 100 loss: 0.2263326346874237
    epoch: 0 step: 200 loss: 0.19458135962486267
    epoch: 1 step: 0 loss: 0.1788959801197052
    epoch: 1 step: 100 loss: 0.15782299637794495
    epoch: 1 step: 200 loss: 0.1580992043018341
    epoch: 2 step: 0 loss: 0.15085121989250183
    epoch: 2 step: 100 loss: 0.1432340145111084
    epoch: 2 step: 200 loss: 0.14373672008514404
    epoch: 3 step: 0 loss: 0.13810500502586365
    epoch: 3 step: 100 loss: 0.13337770104408264
    epoch: 3 step: 200 loss: 0.1334681361913681
    epoch: 4 step: 0 loss: 0.12887853384017944
    epoch: 4 step: 100 loss: 0.12551936507225037
    epoch: 4 step: 200 loss: 0.125375896692276
    epoch: 5 step: 0 loss: 0.12160968780517578
    epoch: 5 step: 100 loss: 0.1190723180770874
    epoch: 5 step: 200 loss: 0.11880680173635483
    epoch: 6 step: 0 loss: 0.11563797295093536
    epoch: 6 step: 100 loss: 0.11367204040288925
    epoch: 6 step: 200 loss: 0.11331651359796524
    epoch: 7 step: 0 loss: 0.11063456535339355
    epoch: 7 step: 100 loss: 0.10906648635864258
    epoch: 7 step: 200 loss: 0.10866570472717285
    epoch: 8 step: 0 loss: 0.10636782646179199
    epoch: 8 step: 100 loss: 0.10510052740573883
    epoch: 8 step: 200 loss: 0.10468046367168427
    epoch: 9 step: 0 loss: 0.10268573462963104
    epoch: 9 step: 100 loss: 0.10163718461990356
    epoch: 9 step: 200 loss: 0.10121693462133408
    epoch: 10 step: 0 loss: 0.09949333965778351
    epoch: 10 step: 100 loss: 0.09859145432710648
    epoch: 10 step: 200 loss: 0.09819269925355911
    epoch: 11 step: 0 loss: 0.0966767817735672
    epoch: 11 step: 100 loss: 0.09586615860462189
    epoch: 11 step: 200 loss: 0.09550992399454117
    epoch: 12 step: 0 loss: 0.09417577087879181
    epoch: 12 step: 100 loss: 0.09341947734355927
    epoch: 12 step: 200 loss: 0.09310202300548553
    epoch: 13 step: 0 loss: 0.09193204343318939
    epoch: 13 step: 100 loss: 0.09122277796268463
    epoch: 13 step: 200 loss: 0.09092779457569122
    epoch: 14 step: 0 loss: 0.0899026170372963
    epoch: 14 step: 100 loss: 0.08923697471618652
    epoch: 14 step: 200 loss: 0.08895798027515411
    epoch: 15 step: 0 loss: 0.08804921805858612
    epoch: 15 step: 100 loss: 0.08742769062519073
    epoch: 15 step: 200 loss: 0.0871589332818985
    epoch: 16 step: 0 loss: 0.08635203540325165
    epoch: 16 step: 100 loss: 0.0857706069946289
    epoch: 16 step: 200 loss: 0.0855005756020546
    epoch: 17 step: 0 loss: 0.08479145169258118
    epoch: 17 step: 100 loss: 0.08423925191164017
    epoch: 17 step: 200 loss: 0.08396687358617783
    epoch: 18 step: 0 loss: 0.08334997296333313
    epoch: 18 step: 100 loss: 0.08281457424163818
    epoch: 18 step: 200 loss: 0.08254452794790268
    epoch: 19 step: 0 loss: 0.08201286941766739
    epoch: 19 step: 100 loss: 0.08149122446775436
    epoch: 19 step: 200 loss: 0.08122102916240692
    
    展开全文
  • 深度学习(一):DNN前向传播算法和反向传播算法

    万次阅读 多人点赞 2018-11-29 17:32:13
    文章目录一、深度神经网络(DNN)模型1.1 从感知机到神经网络1.2 DNN的基本结构二、DNN前向传播算法2.1 DNN前向传播算法数学原理2.2 DNN前向传播算法2.3 DNN前向传播算法小结三、DNN反向传播算法3.1 DNN反向传播算法...

    一、深度神经网络(DNN)模型

    深度神经网络(Deep Neural Networks, 以下简称DNN)是深度学习的基础,而要理解DNN,首先我们要理解DNN模型,下面我们就对DNN的模型与前向传播算法做一个总结。

    1.1 从感知机到神经网络

    感知机的模型大家都比较熟悉,它是一个有若干输入和一个输出的模型,如下图:
    在这里插入图片描述

    输出和输入之间学习到一个线性关系,得到中间输出结果:
    z = ∑ i = 1 m w i x i + b z=\sum\limits_{i=1}^mw_ix_i + b z=i=1mwixi+b

    接着是一个神经元激活函数:
    s i g n ( z ) = { − 1 z < 0 1 z ≥ 0 sign(z)= \begin{cases} -1& {z<0}\\ 1& {z\geq 0} \end{cases} sign(z)={11z<0z0

    从而得到我们想要的输出结果1或者-1。

    这个模型只能用于二元分类,且无法学习比较复杂的非线性模型,因此在工业界无法使用。

    而神经网络则在感知机的模型上做了扩展,总结下主要有三点:

    1)加入了隐藏层,隐藏层可以有多层,增强模型的表达能力,如下图实例,当然增加了这么多隐藏层模型的复杂度也增加了好多。
    在这里插入图片描述

    2)输出层的神经元也可以不止一个输出,可以有多个输出,这样模型可以灵活的应用于分类回归,以及其他的机器学习领域比如降维和聚类等。多个神经元输出的输出层对应的一个实例如下图,输出层现在有4个神经元了。
    在这里插入图片描述

    3) 对激活函数做扩展,感知机的激活函数是 s i g n ( z ) sign(z) sign(z),虽然简单但是处理能力有限,因此神经网络中一般使用的其他的激活函数,比如我们在逻辑回归里面使用过的Sigmoid函数,即:
    f ( z ) = 1 1 + e − z f(z)=\frac{1}{1+e^{-z}} f(z)=1+ez1

    还有后来出现的tanx, softmax,和ReLU等。通过使用不同的激活函数,神经网络的表达能力进一步增强。对于各种常用的激活函数,我随后会整理一份资料。

    1.2 DNN的基本结构

    上一节我们了解了神经网络基于感知机的扩展,而DNN可以理解为有很多隐藏层的神经网络。这个很多其实也没有什么度量标准, 多层神经网络和深度神经网络DNN其实也是指的一个东西,当然,DNN有时也叫做多层感知机(Multi-Layer perceptron,MLP), 名字实在是多。后面我们讲到的神经网络都默认为DNN。

    从DNN按不同层的位置划分,DNN内部的神经网络层可以分为三类,输入层,隐藏层和输出层,如下图示例,一般来说第一层是输入层,最后一层是输出层,而中间的层数都是隐藏层。
    在这里插入图片描述

    层与层之间是全连接的,也就是说,第 i i i层的任意一个神经元一定与第 i + 1 i+1 i+1层的任意一个神经元相连。虽然DNN看起来很复杂,但是从小的局部模型来说,还是和感知机一样,即一个线性关系 z = ∑ w i x i + b z=\sum\limits w_ix_i + b z=wixi+b 加上一个激活函数 σ ( z ) \sigma(z) σ(z)

    由于DNN层数多,则我们的线性关系系数 w w w和偏倚 b b b的数量也就是很多了。具体的参数在DNN是如何定义的呢?

    首先我们来看看线性关系系数 w w w的定义。以下图一个三层的DNN为例,第二层的第4个神经元到第三层的第2个神经元的线性系数定义为 w 24 3 w_{24}^3 w243。上标3代表线性系数 w w w所在的层数,而下标对应的是输出的第三层索引2和输入的第二层索引4。你也许会问,为什么不是 w 42 3 w_{42}^3 w423, 而是 w 24 3 w_{24}^3 w243呢?这主要是为了便于模型用于矩阵表示运算,如果是 w 42 3 w_{42}^3 w423每次进行矩阵运算是 w T x + b w^Tx+b wTx+b,需要进行转置。将输出的索引放在前面的话,则线性运算不用转置,即直接为 w x + b wx+b wx+b总结下,第 l − 1 l−1 l1层的第 k k k个神经元到第 l l l层的第 j j j个神经元的线性系数定义为 w j k l w_{jk}^l wjkl。注意,输入层是没有 w w w参数的。
    在这里插入图片描述

    再来看看偏倚 b b b的定义。还是以这个三层的DNN为例,第二层的第3个神经元对应的偏倚定义为 b 3 2 b_3^{2} b32。其中,上标2代表所在的层数,下标3代表偏倚所在的神经元的索引。输入层是没有偏倚参数 b b b的。

    同样的道理,对于神经元的激活值而言,第3层的第1个神经元的激活值应该表示为 a 1 3 a_1^{3} a13
    在这里插入图片描述

    二、DNN前向传播算法

    2.1 DNN前向传播算法数学原理

    在上一节,我们已经介绍了DNN各层线性关系系数 w w w和偏倚 b b b的定义。假设我们选择的激活函数是 σ ( z ) \sigma(z) σ(z),隐藏层和输出层的输出值为 a a a,则对于下图的三层DNN,利用和感知机一样的思路,我们可以利用上一层的输出计算下一层的输出,也就是所谓的DNN前向传播算法。
    在这里插入图片描述
    对于第二层的的输出 a 1 2 , a 2 2 , a 3 2 a_1^2,a_2^2,a_3^2 a12,a22,a32,我们有:
    a 1 2 = σ ( z 1 2 ) = σ ( w 11 2 x 1 + w 12 2 x 2 + w 13 2 x 3 + b 1 2 ) a_1^2=\sigma(z_1^2) = \sigma(w_{11}^2x_1 + w_{12}^2x_2 + w_{13}^2x_3 + b_1^{2}) a12=σ(z12)=σ(w112x1+w122x2+w132x3+b12)

    a 2 2 = σ ( z 2 2 ) = σ ( w 21 2 x 1 + w 22 2 x 2 + w 23 2 x 3 + b 2 2 ) a_2^2=\sigma(z_2^2) = \sigma(w_{21}^2x_1 + w_{22}^2x_2 + w_{23}^2x_3 + b_2^{2}) a22=σ(z22)=σ(w212x1+w222x2+w232x3+b22)

    a 3 2 = σ ( z 3 2 ) = σ ( w 31 2 x 1 + w 32 2 x 2 + w 33 2 x 3 + b 3 2 ) a_3^2=\sigma(z_3^2) = \sigma(w_{31}^2x_1 + w_{32}^2x_2 + w_{33}^2x_3 + b_3^{2}) a32=σ(z32)=σ(w312x1+w322x2+w332x3+b32)

    对于第三层的的输出 a 1 3 a_1^3 a13,我们有:
    a 1 3 = σ ( z 1 3 ) = σ ( w 11 3 a 1 2 + w 12 3 a 2 2 + w 13 3 a 3 2 + b 1 3 ) a_1^3=\sigma(z_1^3) = \sigma(w_{11}^3a_1^2 + w_{12}^3a_2^2 + w_{13}^3a_3^2 + b_1^{3}) a13=σ(z13)=σ(w113a12+w123a22+w133a32+b13)

    将上面的例子一般化,假设第 l − 1 l−1 l1层共有 m m m个神经元,则对于第 l l l层的第 j j j个神经元的输出 a j l a_j^l ajl,我们有:
    a j l = σ ( z j l ) = σ ( ∑ k = 1 m w j k l a k l − 1 + b j l ) a_j^l = \sigma(z_j^l) = \sigma(\sum\limits_{k=1}^mw_{jk}^la_k^{l-1} + b_j^l) ajl=σ(zjl)=σ(k=1mwjklakl1+bjl)

    其中,如果 l = 2 l=2 l=2,则对于的 a k 1 a_k^1 ak1即为输入层的 x k x_k xk

    从上面可以看出,使用代数法一个个的表示输出比较复杂,而如果使用矩阵法则比较的简洁。假设第 l − 1 l−1 l1层共有 m m m个神经元,而第 l l l层共有 n n n个神经元,则第 l l l层的线性系数 w w w组成了一个 n × m n×m n×m的矩阵 W l W^l Wl, 第 l l l层的偏倚 b b b组成了一个 n × 1 n×1 n×1的向量 b l b^l bl , 第 l − 1 l−1 l1层的输出 a a a组成了一个 m × 1 m×1 m×1的向量 a l − 1 a^{l−1} al1,第 l l l层的未激活前线性输出 z z z组成了一个 n × 1 n×1 n×1的向量 z l z^l zl, 第 l l l层的的输出 a a a组成了一个 n × 1 n×1 n×1的向量 a l a^l al。则用矩阵法表示,第 l l l层的输出为:
    a l = σ ( z l ) = σ ( W l a l − 1 + b l ) a^l = \sigma(z^l) = \sigma(W^la^{l-1} + b^l) al=σ(zl)=σ(Wlal1+bl)

    这个表示方法简洁漂亮,后面我们的讨论都会基于上面的这个矩阵法表示来。所以,应该时刻记住我们符号的含义,否则在后面推导反向传播公式时会比较懵。

    2.2 DNN前向传播算法

    有了上一节的数学推导,DNN的前向传播算法也就不难了。所谓的DNN的前向传播算法也就是利用我们的若干个权重系数矩阵 W W W和偏倚向量 b b b来和输入值向量 x x x进行一系列线性运算和激活运算,从输入层开始,一层层的向后计算,一直到运算到输出层,得到输出结果为止 。

    输入: 总层数 L L L,所有隐藏层和输出层对应的矩阵 W W W,偏倚向量 b b b,输入值向量 x x x
    输出:输出层的输出 a L a^L aL

    • 1) 初始化 a 1 = x a^1=x a1=x

    • 2) for l = 2 l=2 l=2 to L L L, 计算:

    a l = σ ( z l ) = σ ( W l a l − 1 + b l ) a^l = \sigma(z^l) = \sigma(W^la^{l-1} + b^l) al=σ(zl)=σ(Wlal1+bl)

    最后的结果即为输出 a L a^L aL

    2.3 DNN前向传播算法小结

    单独看DNN前向传播算法,似乎没有什么大用处,而且这一大堆的矩阵 W W W,偏倚向量 b b b对应的参数怎么获得呢?怎么得到最优的矩阵 W W W,偏倚向量 b b b呢?这个我们在下一章讲DNN的反向传播算法时再讲。而理解反向传播算法的前提就是理解DNN的模型与前向传播算法。这也是我们先讲前向传播算法的原因。

    三、DNN反向传播算法

    3.1 DNN反向传播算法要解决的问题

    在了解DNN的反向传播算法(Back Propagation,BP)前,我们先要知道DNN反向传播算法要解决的问题,也就是说,什么时候我们需要这个反向传播算法?

    回到我们监督学习的一般问题,假设我们有 m m m个训练样本: { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) } \{(x_1,y_1), (x_2,y_2), ..., (x_m,y_m)\} {(x1,y1),(x2,y2),...,(xm,ym)},其中 x x x为输入向量,特征维度为 n i n n_{in} nin,而 y y y为输出向量,特征维度为 n o u t n_{out} nout。我们需要利用这 m m m个样本训练出一个模型,当有一个新的测试样本 ( x t e s t , ? ) (x_{test},?) (xtest,?)来到时, 我们可以预测 y t e s t y_{test} ytest向量的输出。

    如果我们采用DNN的模型,即我们使输入层有 n i n n_{in} nin个神经元,而输出层有 n o u t n_{out} nout个神经元。再加上一些含有若干神经元的隐藏层。此时我们需要找到合适的所有隐藏层和输出层对应的线性系数矩阵 W W W和偏倚向量 b b b,让所有的训练样本输入计算出的输出尽可能的等于或很接近样本输出。怎么找到合适的参数呢?

    如果大家对传统的机器学习的算法优化过程熟悉的话,这里就很容易联想到我们可以用一个合适的损失函数来度量训练样本的输出损失,接着对这个损失函数进行优化求最小化的极值,对应的一系列线性系数矩阵 W W W和偏倚向量 b b b即为我们的最终结果。在DNN中,损失函数优化极值求解的过程最常见的一般是通过梯度下降法来一步步迭代完成的,当然也可以是其他的迭代方法比如牛顿法与拟牛顿法。

    对DNN的损失函数用梯度下降法进行迭代优化求极小值的过程即为我们的反向传播算法。

    3.2 DNN反向传播算法的基本思路

    在进行DNN反向传播算法前,我们需要选择一个损失函数,来度量训练样本计算出的输出和真实的训练样本输出之间的损失。你也许会问:训练样本计算出的输出是怎么得来的?这个输出是随机选择一系列 W , b W,b W,b,用前向传播算法计算出来的。即通过一系列的计算: a l = σ ( z l ) = σ ( W l a l − 1 + b l ) a^l = \sigma(z^l) = \sigma(W^la^{l-1} + b^l) al=σ(zl)=σ(Wlal1+bl)。计算到输出层第 L L L层对应的 a L a^L aL即为前向传播算法计算出来的输出。

    回到损失函数,DNN可选择的损失函数有不少,为了专注算法,这里我们使用最常见的均方差来度量损失。当然,针对不同的任务,可以选择不同的损失函数。即对于每个样本,我们期望最小化下式:
    J ( W , b , x , y ) = 1 2 ∣ ∣ a L − y ∣ ∣ 2 2 J(W,b,x,y) = \frac{1}{2}||a^L-y||_2^2 J(W,b,x,y)=21aLy22

    其中, a L a^L aL y y y为特征维度为 n o u t n_{out} nout的向量,而 ∣ ∣ S ∣ ∣ 2 ||S||_2 S2 S S S的L2范数。

    损失函数有了,现在我们开始用梯度下降法迭代求解每一层的 W , b W,b W,b

    注:以下是BP算法推导的过程,是本文最核心,也是神经网络最基本的公式推导。

    思路第一步:
    首先是输出层第 L L L层。注意到输出层的 W , b W,b W,b满足下式:
    a L = σ ( z L ) = σ ( W L a L − 1 + b L ) (1) a^L = \sigma(z^L) = \sigma(W^La^{L-1} + b^L) \qquad \text{(1)} aL=σ(zL)=σ(WLaL1+bL)(1)

    这样对于输出层的参数,我们的损失函数变为:
    J ( W , b , x , y ) = 1 2 ∣ ∣ a L − y ∣ ∣ 2 2 = 1 2 ∣ ∣ σ ( W L a L − 1 + b L ) − y ∣ ∣ 2 2 (2) J(W,b,x,y) = \frac{1}{2}||a^L-y||_2^2 = \frac{1}{2}|| \sigma(W^La^{L-1} + b^L)-y||_2^2 \qquad \text{(2)} J(W,b,x,y)=21aLy22=21σ(WLaL1+bL)y22(2)

    这样求解 W , b W,b W,b的梯度就简单了:
    ∂ J ( W , b , x , y ) ∂ W L = ∂ J ( W , b , x , y ) ∂ z L ∂ z L ∂ W L = ∂ J ( W , b , x , y ) ∂ a L ∂ a L ∂ z L ∂ z L ∂ W L = ( a L − y ) ⊙ σ ′ ( z L ) ( a L − 1 ) T (3) \frac{\partial J(W,b,x,y)}{\partial W^L} = \frac{\partial J(W,b,x,y)}{\partial z^L}\frac{\partial z^L}{\partial W^L} =\frac{\partial J(W,b,x,y)}{\partial a^L}\frac{\partial a^L}{\partial z^L}\frac{\partial z^L}{\partial W^L} =(a^L-y) \odot \sigma^{'}(z^L)(a^{L-1})^T\qquad \text{(3)} WLJ(W,b,x,y)=zLJ(W,b,x,y)WLzL=aLJ(W,b,x,y)zLaLWLzL=(aLy)σ(zL)(aL1)T(3)

    ∂ J ( W , b , x , y ) ∂ b L = ∂ J ( W , b , x , y ) ∂ z L ∂ z L ∂ b L = ∂ J ( W , b , x , y ) ∂ a L ∂ a L ∂ z L ∂ z L ∂ b L = ( a L − y ) ⊙ σ ′ ( z L ) (4) \frac{\partial J(W,b,x,y)}{\partial b^L} = \frac{\partial J(W,b,x,y)}{\partial z^L}\frac{\partial z^L}{\partial b^L} =\frac{\partial J(W,b,x,y)}{\partial a^L}\frac{\partial a^L}{\partial z^L}\frac{\partial z^L}{\partial b^L}=(a^L-y)\odot \sigma^{'}(z^L)\qquad \text{(4)} bLJ(W,b,x,y)=zLJ(W,b,x,y)bLzL=aLJ(W,b,x,y)zLaLbLzL=(aLy)σ(zL)(4)

    注意上式中有一个符号 ⊙ \odot ,它代表Hadamard积,对于两个维度相同的向量 A ( a 1 , a 2 , . . . a n ) T A(a_1,a_2,...a_n)^T Aa1,a2,...anT B ( b 1 , b 2 , . . . b n ) T B(b_1,b_2,...b_n)^T Bb1,b2,...bnT,则 A ⊙ B = ( a 1 b 1 , a 2 b 2 , . . . a n b n ) T A \odot B = (a_1b_1, a_2b_2,...a_nb_n)^T AB=(a1b1,a2b2,...anbn)T


    对于公式(3)和(4),我在这里多解释一下为什么是这样:

    对于公式(3):前两项之所以是Hadamard积的形式,是因为 ∂ J ( W , b , x , y ) ∂ a L ∂ a L ∂ z L \frac{\partial J(W,b,x,y)}{\partial a^L}\frac{\partial a^L}{\partial z^L} aLJ(W,b,x,y)zLaL都是针对同一层的神经元。如果我们考虑对于 L L L层的第 j j j个神经元,即 ∂ J ( W , b , x , y ) ∂ a j L σ ′ ( z j L ) \frac{\partial J(W,b,x,y)}{\partial a_j^L}\sigma^{'}(z_j^L) ajLJ(W,b,x,y)σ(zjL),那么整合这一层的神经元,自然是 ( a L − y ) ⊙ σ ′ ( z L ) (a^L-y) \odot \sigma^{'}(z^L) (aLy)σ(zL)这样Hadamard积的形式。那么 ( a L − 1 ) T (a^{L-1})^T (aL1)T为什么在(3)中的最后呢?这涉及到矩阵求导的知识,不是我们本文的重点。在这里,用到的知识是:如果
    Y = W X + B Y=WX+B Y=WX+B

    那么
    ∂ C ∂ W = ∂ C ∂ Y X T \frac{\partial C}{\partial W}=\frac{\partial C}{\partial Y}X^T WC=YCXT

    这样,即可推出公式(3)。公式(4)与公式(3)类似。


    思路第二步:
    我们注意到在求解输出层的 W , b W,b W,b的时候,有公共的部分 ∂ J ( W , b , x , y ) ∂ z L \frac{\partial J(W,b,x,y)}{\partial z^L} zLJ(W,b,x,y),因此我们可以把公共的部分即对 z L z^L zL先算出来,记为:
    δ L = ∂ J ( W , b , x , y ) ∂ z L = ( a L − y ) ⊙ σ ′ ( z L ) (5) \delta^L = \frac{\partial J(W,b,x,y)}{\partial z^L} = (a^L-y)\odot \sigma^{'}(z^L) \qquad \text{(5)} δL=zLJ(W,b,x,y)=(aLy)σ(zL)(5)

    根据公式(3)(4),我们可以把输出层的梯度算出来,那么如何计算上一层 L − 1 L−1 L1层的梯度,上上层 L − 2 L−2 L2层的梯度呢?这里我们需要一步步的递推,注意到对于第 l l l层的未激活输出 z l z^l zl,它的梯度可以表示为:
    δ l = ∂ J ( W , b , x , y ) ∂ z l = ∂ J ( W , b , x , y ) ∂ z L ∂ z L ∂ z L − 1 ∂ z L − 1 ∂ z L − 2 . . . ∂ z l + 1 ∂ z l (6) \delta^l =\frac{\partial J(W,b,x,y)}{\partial z^l} = \frac{\partial J(W,b,x,y)}{\partial z^L}\frac{\partial z^L}{\partial z^{L-1}}\frac{\partial z^{L-1}}{\partial z^{L-2}}...\frac{\partial z^{l+1}}{\partial z^{l}}\qquad \text{(6)} δl=zlJ(W,b,x,y)=zLJ(W,b,x,y)zL1zLzL2zL1...zlzl+1(6)

    如果我们可以依次计算出第 l l l层的 δ l \delta^l δl,则该层的 W l , b l W^l,b^l Wl,bl很容易计算?为什么呢?注意到根据前向传播算法,我们有:
    z l = W l a l − 1 + b l (7) z^l= W^la^{l-1} + b^l\qquad \text{(7)} zl=Wlal1+bl(7)

    所以根据上式我们可以很方便的计算出第 l l l层的 W l , b l W_l,b_l Wl,bl的梯度如下:
    ∂ J ( W , b , x , y ) ∂ W l = ∂ J ( W , b , x , y ) ∂ z l ∂ z l ∂ W l = δ l ( a l − 1 ) T (8) \frac{\partial J(W,b,x,y)}{\partial W^l} = \frac{\partial J(W,b,x,y)}{\partial z^l} \frac{\partial z^l}{\partial W^l} = \delta^{l}(a^{l-1})^T\qquad \text{(8)} WlJ(W,b,x,y)=zlJ(W,b,x,y)Wlzl=δl(al1)T(8)

    ∂ J ( W , b , x , y ) ∂ b l = ∂ J ( W , b , x , y ) ∂ z l ∂ z l ∂ b l = δ l (9) \frac{\partial J(W,b,x,y)}{\partial b^l} = \frac{\partial J(W,b,x,y)}{\partial z^l} \frac{\partial z^l}{\partial b^l} = \delta^{l}\qquad \text{(9)} blJ(W,b,x,y)=zlJ(W,b,x,y)blzl=δl(9)

    思路第三步:
    那么现在问题的关键就是要求出 δ l \delta^l δl了。这里我们用数学归纳法,第 L L L层的 δ L \delta^L δL上面我们已经求出, 假设第 l + 1 l+1 l+1层的 δ l + 1 \delta^{l+1} δl+1已经求出来了,那么我们如何求出第 l l l层的 δ l \delta^l δl呢?我们注意到:
    δ l = ∂ J ( W , b , x , y ) ∂ z l = ∂ J ( W , b , x , y ) ∂ z l + 1 ∂ z l + 1 ∂ z l = δ l + 1 ∂ z l + 1 ∂ z l (10) \delta^{l} = \frac{\partial J(W,b,x,y)}{\partial z^l} = \frac{\partial J(W,b,x,y)}{\partial z^{l+1}}\frac{\partial z^{l+1}}{\partial z^{l}} = \delta^{l+1}\frac{\partial z^{l+1}}{\partial z^{l}}\qquad \text{(10)} δl=zlJ(W,b,x,y)=zl+1J(W,b,x,y)zlzl+1=δl+1zlzl+1(10)

    可见,用归纳法递推 δ l + 1 \delta^{l+1} δl+1 δ l \delta^l δl的关键在于求解 ∂ z l + 1 ∂ z l \frac{\partial z^{l+1}}{\partial z^{l}} zlzl+1

    z l + 1 z^{l+1} zl+1 z l z^l zl的关系其实很容易找出:
    z l + 1 = W l + 1 a l + b l + 1 = W l + 1 σ ( z l ) + b l + 1 (11) z^{l+1}= W^{l+1}a^{l} + b^{l+1} = W^{l+1}\sigma(z^l) + b^{l+1} \qquad \text{(11)} zl+1=Wl+1al+bl+1=Wl+1σ(zl)+bl+1(11)

    这样很容易求出:
    ∂ z l + 1 ∂ z l = ( W l + 1 ) T ⊙ ( σ ′ ( z l ) , . . , σ ′ ( z l ) ) ⏟ n l + 1 (12) \frac{\partial z^{l+1}}{\partial z^{l}} = (W^{l+1})^T\odot \underbrace{(\sigma^{'}(z^l),..,\sigma^{'}(z^l))}_{n_{l+1}}\qquad \text{(12)} zlzl+1=(Wl+1)Tnl+1 (σ(zl),..,σ(zl))(12)

    公式(12)的意思就是 ( W l + 1 ) T (W^{l+1})^T (Wl+1)T的每一列都Hadamard积 σ ′ ( z l ) \sigma^{'}(z^l) σ(zl)

    将公式(12)代入公式(10)我们得到:
    δ l = δ l + 1 ∂ z l + 1 ∂ z l = ( ( W l + 1 ) T δ l + 1 ) ⊙ σ ′ ( z l ) (13) \delta^{l} = \delta^{l+1}\frac{\partial z^{l+1}}{\partial z^{l}} =( (W^{l+1})^T\delta^{l+1})\odot \sigma^{'}(z^l)\qquad \text{(13)} δl=δl+1zlzl+1=((Wl+1)Tδl+1)σ(zl)(13)


    公式(13)的推导过程为:
    δ l + 1 ∂ z l + 1 ∂ z l = ∂ ( δ l + 1 ) T z l + 1 ∂ z l = ∂ ( δ l + 1 ) T ( W l + 1 σ ( z l ) + b l + 1 ) ∂ z l = ∂ ( δ l + 1 ) T W l + 1 σ ( z l ) ∂ z l = ( ( δ l + 1 ) T W l + 1 ) T ⊙ σ ′ ( z l ) = = ( ( W l + 1 ) T δ l + 1 ) ⊙ σ ′ ( z l ) \delta^{l+1}\frac{\partial z^{l+1}}{\partial z^{l}} =\frac{\partial (\delta^{l+1})^T z^{l+1}}{\partial z^{l}} = \frac{\partial (\delta^{l+1})^T (W^{l+1}\sigma(z^l) + b^{l+1})}{\partial z^{l}} = \frac{\partial (\delta^{l+1})^T W^{l+1}\sigma(z^l) }{\partial z^{l}} \\= ((\delta^{l+1})^T W^{l+1})^T\odot \sigma^{'}(z^l) = = ((W^{l+1})^T\delta^{l+1})\odot \sigma^{'}(z^l) δl+1zlzl+1=zl(δl+1)Tzl+1=zl(δl+1)T(Wl+1σ(zl)+bl+1)=zl(δl+1)TWl+1σ(zl)=((δl+1)TWl+1)Tσ(zl)==((Wl+1)Tδl+1)σ(zl)


    现在我们得到了 δ l \delta^l δl的递推关系式,只要求出了某一层的 δ l \delta^l δl,求解 W l , b l W^l,b^l Wl,bl的对应梯度就很简单。

    总结:

    其实,对于更新每一层的 W l , b l W^l,b^l Wl,bl的对应梯度,我们仔细观察整个过程,发现只需要四个公式就可以完整地进行更新。这就是著名的反向传播的四个公式,即公式(5)、(13)、(8)、(9)。我们稍加改动,使其可以应用到多种损失函数,即:

    δ L = ∂ J ∂ a L ⊙ σ ′ ( z L ) (BP1) δ l = ( W l + 1 ) T δ l + 1 ⊙ σ ′ ( z l ) (BP2) ∂ J ∂ W l = δ l ( a l − 1 ) T (BP3) ∂ J ∂ b l = δ l (BP4) \begin{aligned} \delta^L = \frac{\partial J}{\partial a^L} \odot \sigma^{'}(z^L) \qquad \text{(BP1)}\\ \delta^{l} = (W^{l+1})^T\delta^{l+1}\odot \sigma^{'}(z^l)\qquad \text{(BP2)}\\ \frac{\partial J}{\partial W^l} = \delta^{l}(a^{l-1})^T\qquad \text{(BP3)}\\ \frac{\partial J}{\partial b^l} = \delta^{l}\qquad \text{(BP4)} \end{aligned} δL=aLJσ(zL)(BP1)δl=(Wl+1)Tδl+1σ(zl)(BP2)WlJ=δl(al1)T(BP3)blJ=δl(BP4)

    3. 3 DNN反向传播算法过程

    现在我们总结下DNN反向传播算法的过程。由于梯度下降法有批量(Batch),小批量(mini-Batch),随机三个变种,为了简化描述,这里我们以最基本的批量梯度下降法为例来描述反向传播算法。实际上在业界使用最多的是mini-Batch的梯度下降法。不过区别仅仅在于迭代时训练样本的选择而已。

    输入: 总层数 L L L,以及各隐藏层与输出层的神经元个数,激活函数,损失函数,迭代步长 α \alpha α,最大迭代次数MAX与停止迭代阈值 ϵ \epsilon ϵ,输入的 m m m个训练样本 { ( x 1 , y 1 ) , ( x 2 , y 2 ) , . . . , ( x m , y m ) } \{(x_1,y_1), (x_2,y_2), ..., (x_m,y_m)\} {(x1,y1),(x2,y2),...,(xm,ym)}

    输出:各隐藏层与输出层的线性关系系数矩阵 W W W和偏倚向量 b b b

    1)初始化各隐藏层与输出层的线性关系系数矩阵 W W W和偏倚向量 b b b的值为一个随机值

    2)for iter to 1 to MAX:

         2-1) for i = 1 i =1 i=1 to m m m

                        a) 将DNN输入 a 1 a^1 a1设置为 x i x_i xi

                        b) for l = 2 l=2 l=2 to L L L,进行前向传播算法计算 a i , l = σ ( z i , l ) = σ ( W l a i , l − 1 + b l ) a^{i,l} = \sigma(z^{i,l}) = \sigma(W^la^{i,l-1} + b^l) ai,l=σ(zi,l)=σ(Wlai,l1+bl)

                        c) 通过损失函数计算输出层的 δ i , L \delta^{i,L} δi,L(BP1)

                        d) for l = L − 1 l= L-1 l=L1 to 2 2 2, 进行反向传播算法计算 δ i , l = ( W l + 1 ) T δ i , l + 1 ⊙ σ ′ ( z i , l ) \delta^{i,l} = (W^{l+1})^T\delta^{i,l+1}\odot \sigma^{'}(z^{i,l}) δi,l=(Wl+1)Tδi,l+1σ(zi,l)(BP2)

         2-2) for l = 2 l = 2 l=2 to L L L,更新第 l l l层的 W l , b l W^l,b^l Wl,bl:
    W l = W l − α ∑ i = 1 m δ i , l ( a i , l − 1 ) T (BP3) W^l = W^l -\alpha \sum\limits_{i=1}^m \delta^{i,l}(a^{i, l-1})^T \qquad \text{(BP3)} Wl=Wlαi=1mδi,l(ai,l1)T(BP3)

    b l = b l − α ∑ i = 1 m δ i , l (BP4) b^l = b^l -\alpha \sum\limits_{i=1}^m \delta^{i,l} \qquad \text{(BP4)} bl=blαi=1mδi,l(BP4)

         2-3) 如果所有 W W W b b b的变化值都小于停止迭代阈值 ϵ ϵ ϵ,则跳出迭代循环到步骤3。

    3) 输出各隐藏层与输出层的线性关系系数矩阵 W W W和偏倚向量 b b b

    :上述的算法其实看起来有些复杂了,而实际上根据机器学习里普通的批梯度下降算法,我们在求出 m m m个样本的 δ i , L \delta^{i,L} δi,L后,求平均得到 δ L \delta^{L} δL,然后反向继续更新 δ l \delta^{l} δl

    3.4 DNN反向传播算法小结

    有了DNN反向传播算法,我们就可以很方便的用DNN的模型去解决各种监督学习的分类回归问题。当然DNN的参数众多,矩阵运算量也很大,直接使用会有各种各样的问题。有哪些问题以及如何尝试解决这些问题并优化DNN模型与算法,我们会在其它博客里讲。

    参考文献

    【1】深度神经网络(DNN)模型与前向传播算法

    【2】深度神经网络(DNN)反向传播算法(BP)

    本文转自【1】【2】

    【3】Neural Networks and Deep Learning

    【4】数学-矩阵计算(4)两种布局

    【5】Matrix calculus

    【6】反向传播四:反向传播的4个公式

    【7】机器学习中的矩阵、向量求导

    展开全文
  • 传播误差 简介 II . 输出层误差计算公式 III . 隐藏层层误差计算公式 IV . 使用误差更新 连接权值 V . 使用误差更新 单元偏置 VI . 反向传播 过程 VII . 损失函数 简介 VIII . 损失函数 IX . 损失函数 举例 X ....
  • 详解神经网络的前向传播和反向传播(从头推导)

    万次阅读 多人点赞 2018-08-06 17:12:35
    详解神经网络的前向传播和反向传播 本篇博客是对Michael Nielsen所著的《Neural Network and Deep Learning》第2章内容的解读,有兴趣的朋友可以直接阅读原文Neural Network and Deep Learning。  对神经网络有些...
  • 虽然学深度学习有一段时间了,但是对于一些算法的具体实现还是...1.前向传播如图所示,这里讲得已经很清楚了,前向传播的思想比较简单。 举个例子,假设上一层结点i,j,k,…等一些结点与本层的结点w有连接,那么结点
  • 官方信息在现实生活和虚拟网络中的扩散对谣言传播具有双重影响。建立多层网络传播模型研究...且当官方信息的网络传播达到一定规模时,能够有效约束现实社会个体行为,进而达到虚拟层和现实层对谣言控制的同促进作用。
  • 向传播与反向传播

    千次阅读 2019-01-05 12:19:19
    只是由于神经网络的层数过多,参数量过大,再使用前向传播时,计算速度和资源消耗过大。这个时候才出现了反向传播算法。 在了解前向传播和反向传播之前,需要了解复合函数求导法。因为神经网络就可以写成一个复合...
  • RNN的前向传播/后向传播和LSTM

    千次阅读 2019-08-04 20:39:18
    循环网络的前向传播算法非常简单,对于t时刻: 其中ϕ(.)为激活函数,一般来说会选择tanh函数,b为偏置。则 t 时刻的输出: 最终模型的预测输出为: 其中σ为激活函数,激活函数通常选择softmax...
  • 深度学习系列(2):前向传播和后向传播算法

    万次阅读 多人点赞 2017-12-01 23:14:33
    深度学习系列(2):前向传播和后向传播算法前言讲真,之前学吴恩达的机器学习课时,还手写实现过后向传播算法,但如今忘得也一干二净。总结两个原因:1. 理解不够透彻。2. 没有从问题的本质抓住后向传播的精髓。...
  • 开发了考虑非线性弥散作用的缓坡多向不规则波传播变形的数学模型。首先,根据线性波动的叠加原理和波浪方向谱理论,以考虑非线性弥散影响的规则波缓坡方程为基础,推导出考虑非线性弥散影响的缓坡多向不规则波传播...
  • 向传播和反向传播最好的实例就是自己算一一遍。跟着链接一步步走一定能明白的。 所以前向传播并不能带来学习的效果,而反向传播才是学习效果的关键。 关于梯度的问题,反向传播很明显是使用了梯度了。里面的梯度...
  • 二是整理前馈神经网络中正向传播、误差反向传播和梯度下降的原理;三是梯度消失和梯度爆炸问题的原因及解决思路。 一、神经网络结构 目前比较常用的神经网络结构有如下三种: 1、前馈神经网络 前馈神经网络...
  • 本文只包含CNN的前向传播和反向传播,主要是卷积层和pool层的前向传播和反向传播,一些卷积网络的基础知识不涉及 符号表示 如果lll层是卷积层: p[l]p[l]p^{[l]}: padding s[l]s[l]s^{[l]}: stride n[l]cnc...
  • 本文由@星沉阁冰不语出品,转载请注明作者和出处。文章链接:...因为最重要事情就是生成各种矩阵并初始化。神经网络中的重点和核心就是本文的内容——前
  • 此处自己写的sigmoid的后向传播梯度只适用于2分类,且标签为[0,1,0,1…]这种列表形式,后向梯度计算时利用CS231N的梯度校验函数算出来的梯度和自己算的梯度总是相差2倍关系,最后发现可能是计算是将1标签和0标签的...
  • 2.1 前向传播 2.1.1 输入层到隐含层 NET(h1)=w1*i1+w2*i2+b1=0.25*0.02+0.25*0.04+0.4=0.005+0.01+0.4=0.415 神经元h1到输出h1的激活函数是sigmoid OUT(h1)=1/(1+e^(-NET(h1)))=1/(1+0.660340281)=0.602286177 同理...
  • 本文来自于csdn,本文首先简单介绍CNN的结构,并不作详细介绍....2、由于在前向传播的时候,池化层会对前一层卷积层进行放缩,那么从池化层到卷积层BP的时候,小尺度的池化层怎么把误差反传到大尺度的卷积层(这
  • 在前面我们讲述了DNN的模型与前向反向传播算法。而在DNN大类中,卷积神经网络(Convolutional Neural ...然后在此基础上,介绍CNN的前向传播算法和反向传播算法。 在学习CNN前,推荐大家先学习DNN的知识。如果不熟悉...
  • 针对自由空间模型在预测射频识别系统识别距离时存在的偏差,综合考虑射频识别系统应用的传播环境,建立一种无源超高频射频识别系统电波传播模型,并重点分析了前链路路径损耗的主要影响因素及其计算方法。...
  • 向传播和反向传播(举例说明)

    万次阅读 多人点赞 2017-09-19 16:25:06
    假设神经网络结构如下图所示:有2个...----前向传播---- 隐含层神经元h1的输入: 代入数据可得: 假设激励函数用logistic函数,计算得隐含层神经元h1的输出: 同样的方法,可以得到隐含层神经元h
  • 卷积神经网络之前向传播算法

    千次阅读 2018-10-20 21:08:40
    明确得到保研名额的时候已经是9月18号,然而国家推免系统开放时间是9月28号,也就是说我只还有10天时间准备保研,而且这个时间点很学校夏令营、预报名活动早已结束,不再接受学生申请。所以能够申请的学校也就很.....
  • 首先是前向传播的程序。为了更清晰我们分段讲解。 第一部分导入模块,并设置输入节点为28*28,输出节点为10(0到9共10个数字),第一层的节点为500(随便设的) import tensorflow as tf INPUT_NODE = 784 OUTPUT...
  • 1. 前向传播算法 所谓的前向传播算法就是:将上一层的输出作为下一层的输入,并计算下一层的输出,一直到运算到输出层为止。 从上面可以看出,使用代数法一个个的表示输出比较复杂,而如果使用矩阵法则比较的简洁...
  • 先计算每一层的状态和激活值,直到最后一层(即信号是前向传播的); 计算每一层的误差,误差的计算过程是从最后一层向前推进的(这就是反向传播算法名字的由来); 更新参数(目标是误差变小)。迭代前面两个步骤,...
  • 向传播算法

    千次阅读 2017-07-10 20:01:59
    一个神经元有个输入和一个输出,每个神经元的输入既可以是其他神经元的输出也可以是整个神经网络的输入。所谓神经网络的结构就是指的是不同的神经元之间的连接结构。 如图所示,一个最简单的神经元结构的输出就是...
  • LSTM-基本原理-前向传播与反向传播过程推导

    万次阅读 多人点赞 2018-07-24 23:15:25
    最近在实践中用到LSTM模型,一直在查找相关资料,推导其前向传播、反向传播过程。 LSTM有很变体,查到的资料的描述也略有差别,且有一些地方让我觉得有些困惑。目前查到的资料中我认为这个国外大神的博客写的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 212,209
精华内容 84,883
关键字:

多向传播