前向传播和反向传播
 
1. 前向传播
1.1 前向传播过程
1.2 用Tensorflow表示前向传播
1.3 实现神经网络前向传播过程，网络自动推理出输出 y 的值
  
2. 反向传播
2.1 损失函数
2.2 反向传播训练方法：以减小 loss 值为优化目标
 

 
例程：生产一批零件，将体积X1和重量X2为特征输入NN，通过NN后输出一个数值
 
1. 前向传播
 
 
 
前向传播就是搭建模型的计算过程，让模型具有推理能力，可以针对一组输入给出相应的输出
 
 
1.1 前向传播过程
 
 
第一层
 
X
$W^{(}{1}^{)}$
a
x 表示输入，是一个 1 行 2 列矩阵，表示1次输入1组特征(包含了体积和重量两个元素)
对于第一层的 w 前面有两个节点,后面有三个节点 $W^{(}{1}^{)}$ 应该是个2行3列矩阵
a 为第一层网络，a 是一个1行3列矩阵
第二层
 
$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
解释
定义
求前向传播计算结果与已知答案之差的平方再求平均
公式
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
 

本博客是对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 手把手教你实现前向传播
 
概述
会用到的函数
张量最小值
张量最大值
数据集分批
迭代
截断正态分布
relu 激活函数
one_hot
assign_sub
  
准备工作
train 函数
  
run 函数
完整代码

 
概述
 
前向传播 (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）模型
1.1 从感知机到神经网络
1.2 DNN的基本结构
  
二、DNN前向传播算法
2.1 DNN前向传播算法数学原理
2.2 DNN前向传播算法
2.3 DNN前向传播算法小结
  
三、DNN反向传播算法
3.1 DNN反向传播算法要解决的问题
3.2 DNN反向传播算法的基本思路
3. 3 DNN反向传播算法过程
3.4 DNN反向传播算法小结
  
参考文献

 
一、深度神经网络（DNN）模型
 
深度神经网络（Deep Neural Networks， 以下简称DNN）是深度学习的基础，而要理解DNN，首先我们要理解DNN模型，下面我们就对DNN的模型与前向传播算法做一个总结。
 
1.1 从感知机到神经网络
 
感知机的模型大家都比较熟悉，它是一个有若干输入和一个输出的模型，如下图:
 
 
输出和输入之间学习到一个线性关系，得到中间输出结果：
 $$z=\sum _{i=1}^m{w}_i{x}_i+b$$
 
接着是一个神经元激活函数:
 $$sign(z)=\{\begin{array}{ll}-1& z<0\\ 1& z\ge 0\end{array}$$
 
从而得到我们想要的输出结果1或者-1。
 
这个模型只能用于二元分类，且无法学习比较复杂的非线性模型，因此在工业界无法使用。
 
而神经网络则在感知机的模型上做了扩展，总结下主要有三点：
 
1）加入了隐藏层，隐藏层可以有多层，增强模型的表达能力，如下图实例，当然增加了这么多隐藏层模型的复杂度也增加了好多。
 
 
2）输出层的神经元也可以不止一个输出，可以有多个输出，这样模型可以灵活的应用于分类回归，以及其他的机器学习领域比如降维和聚类等。多个神经元输出的输出层对应的一个实例如下图，输出层现在有4个神经元了。
 
 
3） 对激活函数做扩展，感知机的激活函数是$sign(z)$，虽然简单但是处理能力有限，因此神经网络中一般使用的其他的激活函数，比如我们在逻辑回归里面使用过的Sigmoid函数，即：
 $$f(z)=\frac{1}{1+e^{-z}}$$
 
还有后来出现的tanx, softmax,和ReLU等。通过使用不同的激活函数，神经网络的表达能力进一步增强。对于各种常用的激活函数，我随后会整理一份资料。
 
1.2 DNN的基本结构
 
上一节我们了解了神经网络基于感知机的扩展，而DNN可以理解为有很多隐藏层的神经网络。这个很多其实也没有什么度量标准, 多层神经网络和深度神经网络DNN其实也是指的一个东西，当然，DNN有时也叫做多层感知机（Multi-Layer perceptron,MLP）, 名字实在是多。后面我们讲到的神经网络都默认为DNN。
 
从DNN按不同层的位置划分，DNN内部的神经网络层可以分为三类，输入层，隐藏层和输出层，如下图示例，一般来说第一层是输入层，最后一层是输出层，而中间的层数都是隐藏层。
 
 
层与层之间是全连接的，也就是说，第$i$层的任意一个神经元一定与第$i+1$层的任意一个神经元相连。虽然DNN看起来很复杂，但是从小的局部模型来说，还是和感知机一样，即一个线性关系$z=\sum w_i{x}_i+b$ 加上一个激活函数$\sigma (z)$。
 
由于DNN层数多，则我们的线性关系系数$w$和偏倚$b$的数量也就是很多了。具体的参数在DNN是如何定义的呢？
 
首先我们来看看线性关系系数$w$的定义。以下图一个三层的DNN为例，第二层的第4个神经元到第三层的第2个神经元的线性系数定义为$w_{24}^3$。上标3代表线性系数$w$所在的层数，而下标对应的是输出的第三层索引2和输入的第二层索引4。你也许会问，为什么不是$w_{42}^3$, 而是$w_{24}^3$呢？这主要是为了便于模型用于矩阵表示运算，如果是$w_{42}^3$每次进行矩阵运算是$w^{T}x+b$，需要进行转置。将输出的索引放在前面的话，则线性运算不用转置，即直接为$wx+b$。总结下，第$l-1$层的第$k$个神经元到第$l$层的第$j$个神经元的线性系数定义为$w_{jk}^l$。注意，输入层是没有$w$参数的。
 
 
再来看看偏倚$b$的定义。还是以这个三层的DNN为例，第二层的第3个神经元对应的偏倚定义为$b_3^2$。其中，上标2代表所在的层数，下标3代表偏倚所在的神经元的索引。输入层是没有偏倚参数$b$的。
 
同样的道理，对于神经元的激活值而言，第3层的第1个神经元的激活值应该表示为$a_1^3$。
 
 
二、DNN前向传播算法
 
2.1 DNN前向传播算法数学原理
 
在上一节，我们已经介绍了DNN各层线性关系系数$w$和偏倚$b$的定义。假设我们选择的激活函数是$\sigma (z)$，隐藏层和输出层的输出值为$a$，则对于下图的三层DNN，利用和感知机一样的思路，我们可以利用上一层的输出计算下一层的输出，也就是所谓的DNN前向传播算法。
 
 对于第二层的的输出$a_1^2,a_2^2,a_3^2$，我们有：
 $$a_1^2=\sigma (z_1^2)=\sigma (w_{11}^2{x}_1+w_{12}^2{x}_2+w_{13}^2{x}_3+b_1^2)$$
 
$$a_2^2=\sigma (z_2^2)=\sigma (w_{21}^2{x}_1+w_{22}^2{x}_2+w_{23}^2{x}_3+b_2^2)$$
 
$$a_3^2=\sigma (z_3^2)=\sigma (w_{31}^2{x}_1+w_{32}^2{x}_2+w_{33}^2{x}_3+b_3^2)$$
 
对于第三层的的输出$a_1^3$，我们有：
 $$a_1^3=\sigma (z_1^3)=\sigma (w_{11}^3{a}_1^2+w_{12}^3{a}_2^2+w_{13}^3{a}_3^2+b_1^3)$$
 
将上面的例子一般化，假设第$l-1$层共有$m$个神经元，则对于第$l$层的第$j$个神经元的输出$a_j^l$，我们有：
 $$a_j^l=\sigma (z_j^l)=\sigma (\sum _{k=1}^m{w}_{jk}^l{a}_k^{l-1}+b_j^l)$$
 
其中，如果$l=2$，则对于的$a_k^1$即为输入层的$x_k$。
 
从上面可以看出，使用代数法一个个的表示输出比较复杂，而如果使用矩阵法则比较的简洁。假设第$l-1$层共有$m$个神经元，而第$l$层共有$n$个神经元，则第$l$层的线性系数$w$组成了一个$n\times m$的矩阵$W^l$, 第$l$层的偏倚$b$组成了一个$n\times 1$的向量$b^l$ , 第$l-1$层的输出$a$组成了一个$m\times 1$的向量$a^{l-1}$，第$l$层的未激活前线性输出$z$组成了一个$n\times 1$的向量$z^l$, 第$l$层的的输出$a$组成了一个$n\times 1$的向量$a^l$。则用矩阵法表示，第$l$层的输出为：
 $$a^l=\sigma (z^l)=\sigma (W^l{a}^{l-1}+b^l)$$
 
这个表示方法简洁漂亮，后面我们的讨论都会基于上面的这个矩阵法表示来。所以，应该时刻记住我们符号的含义，否则在后面推导反向传播公式时会比较懵。
 
2.2 DNN前向传播算法
 
有了上一节的数学推导，DNN的前向传播算法也就不难了。所谓的DNN的前向传播算法也就是利用我们的若干个权重系数矩阵$W$和偏倚向量$b$来和输入值向量$x$进行一系列线性运算和激活运算，从输入层开始，一层层的向后计算，一直到运算到输出层，得到输出结果为止 。
 
输入: 总层数$L$，所有隐藏层和输出层对应的矩阵$W$，偏倚向量$b$，输入值向量$x$
 输出：输出层的输出$a^L$
 
 
1） 初始化$a^1=x$
 
 
2） for $l=2$ to $L$, 计算：
 
 
$$a^l=\sigma (z^l)=\sigma (W^l{a}^{l-1}+b^l)$$
 
最后的结果即为输出$a^L$。
 
2.3 DNN前向传播算法小结
 
单独看DNN前向传播算法，似乎没有什么大用处，而且这一大堆的矩阵$W$,偏倚向量$b$对应的参数怎么获得呢？怎么得到最优的矩阵$W$,偏倚向量$b$呢？这个我们在下一章讲DNN的反向传播算法时再讲。而理解反向传播算法的前提就是理解DNN的模型与前向传播算法。这也是我们先讲前向传播算法的原因。
 
三、DNN反向传播算法
 
3.1 DNN反向传播算法要解决的问题
 
在了解DNN的反向传播算法（Back Propagation，BP）前，我们先要知道DNN反向传播算法要解决的问题，也就是说，什么时候我们需要这个反向传播算法？
 
回到我们监督学习的一般问题，假设我们有$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$为输入向量，特征维度为$n_{in}$，而$y$为输出向量，特征维度为$n_{out}$。我们需要利用这$m$个样本训练出一个模型，当有一个新的测试样本$(x_{test},?)$来到时, 我们可以预测$y_{test}$向量的输出。
 
如果我们采用DNN的模型，即我们使输入层有$n_{in}$个神经元，而输出层有$n_{out}$个神经元。再加上一些含有若干神经元的隐藏层。此时我们需要找到合适的所有隐藏层和输出层对应的线性系数矩阵$W$和偏倚向量$b$，让所有的训练样本输入计算出的输出尽可能的等于或很接近样本输出。怎么找到合适的参数呢？
 
如果大家对传统的机器学习的算法优化过程熟悉的话，这里就很容易联想到我们可以用一个合适的损失函数来度量训练样本的输出损失，接着对这个损失函数进行优化求最小化的极值，对应的一系列线性系数矩阵$W$和偏倚向量$b$即为我们的最终结果。在DNN中，损失函数优化极值求解的过程最常见的一般是通过梯度下降法来一步步迭代完成的，当然也可以是其他的迭代方法比如牛顿法与拟牛顿法。
 
对DNN的损失函数用梯度下降法进行迭代优化求极小值的过程即为我们的反向传播算法。
 
3.2 DNN反向传播算法的基本思路
 
在进行DNN反向传播算法前，我们需要选择一个损失函数，来度量训练样本计算出的输出和真实的训练样本输出之间的损失。你也许会问：训练样本计算出的输出是怎么得来的？这个输出是随机选择一系列$W,b$，用前向传播算法计算出来的。即通过一系列的计算：$a^l=\sigma (z^l)=\sigma (W^l{a}^{l-1}+b^l)$。计算到输出层第$L$层对应的$a^L$即为前向传播算法计算出来的输出。
 
回到损失函数，DNN可选择的损失函数有不少，为了专注算法，这里我们使用最常见的均方差来度量损失。当然，针对不同的任务，可以选择不同的损失函数。即对于每个样本，我们期望最小化下式：
 $$J(W,b,x,y)=\frac{1}{2}||a^L-y|{|}_2^2$$
 
其中，$a^L$和$y$为特征维度为$n_{out}$的向量，而$||S|{|}_2$为$S$的L2范数。
 
损失函数有了，现在我们开始用梯度下降法迭代求解每一层的$W,b$。
 
注：以下是BP算法推导的过程，是本文最核心，也是神经网络最基本的公式推导。
 
思路第一步：
 首先是输出层第$L$层。注意到输出层的$W,b$满足下式：
 $$a^L=\sigma (z^L)=\sigma (W^L{a}^{L-1}+b^L)\text{(1)}$$
 
这样对于输出层的参数，我们的损失函数变为：
 $$J(W,b,x,y)=\frac{1}{2}||a^L-y|{|}_2^2=\frac{1}{2}||\sigma (W^L{a}^{L-1}+b^L)-y|{|}_2^2\text{(2)}$$
 
这样求解$W,b$的梯度就简单了：
 $$\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 }^{{}^{\prime }}(z^L)(a^{L-1}{)}^T\text{(3)}$$
 
$$\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 }^{{}^{\prime }}(z^L)\text{(4)}$$
 
注意上式中有一个符号$\odot$,它代表Hadamard积，对于两个维度相同的向量$A（a_1,a_2,...a_n{）}^T$和$B（b_1,b_2,...b_n{）}^T$，则$A\odot B=(a_1{b}_1,a_2{b}_2,...a_n{b}_n{)}^T$。
 
 
对于公式（3）和（4），我在这里多解释一下为什么是这样：
 
对于公式（3）：前两项之所以是Hadamard积的形式，是因为$\frac{\partial J(W,b,x,y)}{\partial a^L}\frac{\partial a^L}{\partial z^L}$都是针对同一层的神经元。如果我们考虑对于$L$层的第$j$个神经元，即$\frac{\partial J(W,b,x,y)}{\partial a_j^L}{\sigma }^{{}^{\prime }}(z_j^L)$，那么整合这一层的神经元，自然是$(a^L-y)\odot {\sigma }^{{}^{\prime }}(z^L)$这样Hadamard积的形式。那么$(a^{L-1}{)}^T$为什么在（3）中的最后呢？这涉及到矩阵求导的知识，不是我们本文的重点。在这里，用到的知识是：如果
 $$Y=WX+B$$
 
那么
 $$\frac{\partial C}{\partial W}=\frac{\partial C}{\partial Y}{X}^T$$
 
这样，即可推出公式（3）。公式（4）与公式（3）类似。
 
 
思路第二步：
 我们注意到在求解输出层的$W,b$的时候，有公共的部分$\frac{\partial J(W,b,x,y)}{\partial z^L}$，因此我们可以把公共的部分即对$z^L$先算出来，记为：
 $${\delta }^L=\frac{\partial J(W,b,x,y)}{\partial z^L}=(a^L-y)\odot {\sigma }^{{}^{\prime }}(z^L)\text{(5)}$$
 
根据公式（3）（4），我们可以把输出层的梯度算出来，那么如何计算上一层$L-1$层的梯度，上上层$L-2$层的梯度呢？这里我们需要一步步的递推，注意到对于第$l$层的未激活输出$z^l$，它的梯度可以表示为:
 $${\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}\text{(6)}$$
 
如果我们可以依次计算出第$l$层的${\delta }^l$,则该层的$W^l,b^l$很容易计算？为什么呢？注意到根据前向传播算法，我们有：
 $$z^l=W^l{a}^{l-1}+b^l\text{(7)}$$
 
所以根据上式我们可以很方便的计算出第$l$层的$W_l,b_l$的梯度如下：
 $$\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\text{(8)}$$
 
$$\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\text{(9)}$$
 
思路第三步：
 那么现在问题的关键就是要求出${\delta }^l$了。这里我们用数学归纳法，第$L$层的${\delta }^L$上面我们已经求出， 假设第$l+1$层的${\delta }^{l+1}$已经求出来了，那么我们如何求出第$l$层的${\delta }^l$呢？我们注意到：
 $${\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}\text{(10)}$$
 
可见，用归纳法递推${\delta }^{l+1}$和${\delta }^l$的关键在于求解$\frac{\partial z^{l+1}}{\partial z^l}$。
 
而$z^{l+1}$和$z^l$的关系其实很容易找出：
 $$z^{l+1}=W^{l+1}{a}^l+b^{l+1}=W^{l+1}\sigma (z^l)+b^{l+1}\text{(11)}$$
 
这样很容易求出：
 $$\frac{\partial z^{l+1}}{\partial z^l}=(W^{l+1}{)}^T\odot \underset{n_{l+1}}{\underbrace{({\sigma }^{{}^{\prime }}(z^l),..,{\sigma }^{{}^{\prime }}(z^l))}}\text{(12)}$$
 
公式（12）的意思就是$(W^{l+1}{)}^T$的每一列都Hadamard积${\sigma }^{{}^{\prime }}(z^l)$。
 
将公式（12）代入公式（10）我们得到：
 $${\delta }^l={\delta }^{l+1}\frac{\partial z^{l+1}}{\partial z^l}=((W^{l+1}{)}^T{\delta }^{l+1})\odot {\sigma }^{{}^{\prime }}(z^l)\text{(13)}$$
 
 
公式（13）的推导过程为：
 $$\begin{gathered} {\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 }^{{}^{\prime }}(z^l)==((W^{l+1}{)}^T{\delta }^{l+1})\odot {\sigma }^{{}^{\prime }}(z^l) \end{gathered}$$
 
 
现在我们得到了${\delta }^l$的递推关系式，只要求出了某一层的${\delta }^l$，求解$W^l,b^l$的对应梯度就很简单。
 
总结：
 
其实，对于更新每一层的$W^l,b^l$的对应梯度，我们仔细观察整个过程，发现只需要四个公式就可以完整地进行更新。这就是著名的反向传播的四个公式，即公式(5)、(13)、(8)、(9)。我们稍加改动，使其可以应用到多种损失函数，即：
 
$$\begin{array}{r}{\delta }^L=\frac{\partial J}{\partial a^L}\odot {\sigma }^{{}^{\prime }}(z^L)\text{(BP1)}\\ {\delta }^l=(W^{l+1}{)}^T{\delta }^{l+1}\odot {\sigma }^{{}^{\prime }}(z^l)\text{(BP2)}\\ \frac{\partial J}{\partial W^l}={\delta }^l(a^{l-1}{)}^T\text{(BP3)}\\ \frac{\partial J}{\partial b^l}={\delta }^l\text{(BP4)}\end{array}$$
 
3. 3 DNN反向传播算法过程
 
现在我们总结下DNN反向传播算法的过程。由于梯度下降法有批量（Batch），小批量(mini-Batch)，随机三个变种，为了简化描述，这里我们以最基本的批量梯度下降法为例来描述反向传播算法。实际上在业界使用最多的是mini-Batch的梯度下降法。不过区别仅仅在于迭代时训练样本的选择而已。
 
输入: 总层数$L$，以及各隐藏层与输出层的神经元个数，激活函数，损失函数，迭代步长$\alpha$，最大迭代次数MAX与停止迭代阈值$ϵ$，输入的$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$和偏倚向量$b$
 
1）初始化各隐藏层与输出层的线性关系系数矩阵$W$和偏倚向量$b$的值为一个随机值。
 
2）for iter to 1 to MAX：
 
    　2-1) for $i=1$ to $m$：
 
                    a) 将DNN输入$a^1$设置为$x_i$
 
                    b) for $l=2$ to $L$，进行前向传播算法计算$a^{i,l}=\sigma (z^{i,l})=\sigma (W^l{a}^{i,l-1}+b^l)$
 
                    c) 通过损失函数计算输出层的${\delta }^{i,L}$（BP1）
 
                    d) for $l=L-1$ to $2$, 进行反向传播算法计算${\delta }^{i,l}=(W^{l+1}{)}^T{\delta }^{i,l+1}\odot {\sigma }^{{}^{\prime }}(z^{i,l})$（BP2）
 
    　2-2) for $l=2$ to $L$，更新第$l$层的$W^l,b^l$:
 $$W^l=W^l-\alpha \sum _{i=1}^m{\delta }^{i,l}(a^{i,l-1}{)}^T\text{(BP3)}$$
 
$$b^l=b^l-\alpha \sum _{i=1}^m{\delta }^{i,l}\text{(BP4)}$$
 
    　2-3) 如果所有$W$，$b$的变化值都小于停止迭代阈值$ϵ$，则跳出迭代循环到步骤3。
 
3） 输出各隐藏层与输出层的线性关系系数矩阵$W$和偏倚向量$b$。
 
注：上述的算法其实看起来有些复杂了，而实际上根据机器学习里普通的批梯度下降算法，我们在求出$m$个样本的${\delta }^{i,L}$后，求平均得到${\delta }^L$，然后反向继续更新${\delta }^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】机器学习中的矩阵、向量求导